[dev.ssa] Merge remote-tracking branch 'origin/master' into mergebranch

Semi-regular merge from tip to dev.ssa.

Two fixes:
1) Mark selectgo as not returning.  This caused problems
   because there are no VARKILL ops on the selectgo path,
   causing things to be marked live that shouldn't be.
2) Tell the amd64 assembler that addressing modes like
   name(SP)(AX*4) are ok.

Change-Id: I9ca81c76391b1a65cc47edc8610c70ff1a621913

diff --git a/doc/asm.html b/doc/asm.html
index 2af2005143f65b09db5801983a129a6afec2631c..cce2fe2b8df995f73ba123aa10383573f9b4bf8b 100644 (file)
--- a/doc/asm.html
+++ b/doc/asm.html
@@ -12,7 +12,7 @@ The document is not comprehensive.
 
 <p>
 The assembler is based on the input style of the Plan 9 assemblers, which is documented in detail
-<a href="http://plan9.bell-labs.com/sys/doc/asm.html">elsewhere</a>.
+<a href="https://9p.io/sys/doc/asm.html">elsewhere</a>.
 If you plan to write assembly language, you should read that document although much of it is Plan 9-specific.
 The current document provides a summary of the syntax and the differences with
 what is explained in that document, and
@@ -23,7 +23,7 @@ describes the peculiarities that apply when writing assembly code to interact wi
 The most important thing to know about Go's assembler is that it is not a direct representation of the underlying machine.
 Some of the details map precisely to the machine, but some do not.
 This is because the compiler suite (see
-<a href="http://plan9.bell-labs.com/sys/doc/compiler.html">this description</a>)
+<a href="https://9p.io/sys/doc/compiler.html">this description</a>)
 needs no assembler pass in the usual pipeline.
 Instead, the compiler operates on a kind of semi-abstract instruction set,
 and instruction selection occurs partly after code generation.

diff --git a/doc/codewalk/codewalk.xml b/doc/codewalk/codewalk.xml
index 3496db71d76ceed794ad09c96e8684a877a55815..34e6e91938e75a178da63c8547213eeea8b05d18 100644 (file)
--- a/doc/codewalk/codewalk.xml
+++ b/doc/codewalk/codewalk.xml
@@ -91,7 +91,7 @@
 
        The full address syntax is summarized in this table
        (an excerpt of Table II from
-       <a href="http://plan9.bell-labs.com/sys/doc/sam/sam.html">The text editor <code>sam</code></a>):
+       <a href="https://9p.io/sys/doc/sam/sam.html">The text editor <code>sam</code></a>):
        <br/><br/>
 
        <table>

diff --git a/doc/go1.6.html b/doc/go1.6.html
index 61b2449dad062c8729cd6eefbc21c8e19cfc4eb1..6e3710cbad225e8e3fe155966d6357b37f862ebe 100644 (file)
--- a/doc/go1.6.html
+++ b/doc/go1.6.html
@@ -118,10 +118,10 @@ instead of generated from <a href="/cmd/yacc/">yacc</a>.
 </p>
 
 <p>
-The compiler, linker, and <code>go</code> command have new flag <code>-msan</code>,
+The compiler, linker, and <code>go</code> command have a new flag <code>-msan</code>,
 analogous to <code>-race</code> and only available on linux/amd64,
 that enables interoperation with the <a href="http://clang.llvm.org/docs/MemorySanitizer.html">Clang MemorySanitizer</a>.
-Such interoperation useful mainly for testing a program containing suspect C or C++ code.
+Such interoperation is useful mainly for testing a program containing suspect C or C++ code.
 </p>
 
 <p>
@@ -341,6 +341,19 @@ and changing the global timer resolution caused problems on some systems,
 so the call has been removed.
 </p>
 
+<p>
+When using <code>-buildmode=c-archive</code> or
+<code>-buildmode=c-shared</code> to build an archive or a shared
+library, the handling of signals has changed.
+In Go 1.5 the archive or shared library would install a signal handler
+for most signals.
+In Go 1.6 it will only install a signal handler for the
+synchronous signals needed to handle run-time panics in Go code:
+SIGBUS, SIGFPE, SIGSEGV.
+See the <a href="/pkg/os/signal">os/signal</a> package for more
+details.
+</p>
+
 <h3 id="reflect">Reflect</h3>
 
 <p>
@@ -451,20 +464,8 @@ Second, the new <a href="/pkg/text/template/#hdr-Actions"><code>{{"{{"}}block}}<
 combined with allowing redefinition of named templates,
 provides a simple way to define pieces of a template that
 can be replaced in different instantiations.
-For example, the template
-</p>
-
-<pre>
-&lt;title&gt;{{"{{"}}block "title"}}Page Title{{"{{"}}end}}&lt;/title&gt;
-&lt;body&gt;
-&lt;h1&gt;{{"{{"}}template "title"}}&lt;/h1&gt;
-{{"{{"}}block "page"}}Main text{{"{{"}}end}}
-</pre>
-
-<p>
-defines the basic formatting of a web page. A program can then
-overlay that template with new definitions for the <code>"title"</code>
-and <code>"page"</code> blocks to reuse the formatting for another page.
+There is <a href="/pkg/text/template/#example_Template_block">an example</a>
+in the <code>text/template</code> package that demonstrates this new feature.
 </p>
 
 <h3 id="minor_library_changes">Minor changes to the library</h3>
@@ -588,7 +589,7 @@ Also in the <a href="/pkg/encoding/asn1/"><code>encoding/asn1</code></a> package
 The <a href="/pkg/encoding/base64"><code>encoding/base64</code></a> package's
 <a href="/pkg/encoding/base64/#Decoder"><code>Decoder</code></a> has been fixed
 to process the final bytes of its input. Previously it processed as many four-byte tokens as
-possible but ignore the remainder, up to three bytes.
+possible but ignored the remainder, up to three bytes.
 The <code>Decoder</code> therefore now handles inputs in unpadded encodings (like
 <a href="/pkg/encoding/base64/#RawURLEncoding">RawURLEncoding</a>) correctly,
 but it also rejects inputs in padded encodings that are truncated or end with invalid bytes,
@@ -631,17 +632,17 @@ In previous releases, the argument to <code>*</code> was required to have type <
 Also in the <a href="/pkg/fmt/"><code>fmt</code></a> package,
 <a href="/pkg/fmt/#Scanf"><code>Scanf</code></a> can now scan hexadecimal strings using %X, as an alias for %x.
 Both formats accept any mix of upper- and lower-case hexadecimal.
-<a href="golang.org/x/13585">TODO: Keep?</a>
+<a href="https://golang.org/issues/13585">TODO: Keep?</a>
 </li>
 
 <li>
 The <a href="/pkg/image/"><code>image</code></a>
 and
-The <a href="/pkg/image/color/"><code>image/color</code></a> packages
+<a href="/pkg/image/color/"><code>image/color</code></a> packages
 add
 <a href="/pkg/image/#NYCbCrA"><code>NYCbCrA</code></a>
 and
-<a href="/pkg/color/#NYCbCrA"><code>NYCbCrA</code></a>
+<a href="/pkg/image/color/#NYCbCrA"><code>NYCbCrA</code></a>
 types, to support Y'CbCr images with non-premultiplied alpha.
 </li>
 
@@ -725,22 +726,31 @@ This is arguably a mistake but is not yet fixed. See https://golang.org/issue/13
 The <a href="/pkg/net/http/"><code>net/http</code></a> package has
 a number of minor additions beyond the HTTP/2 support already discussed.
 First, the
-<a href="/pkg/http/#FileServer"><code>FileServer</code></a> now sorts its generated directory listings by file name.
+<a href="/pkg/net/http/#FileServer"><code>FileServer</code></a> now sorts its generated directory listings by file name.
 Second, the
-<a href="/pkg/http/#Client"><code>Client</code></a> now allows user code to set the
+<a href="/pkg/net/http/#ServeFile"><code>ServeFile</code></a> function now refuses to serve a result
+if the request's URL path contains &ldquo;..&rdquo; (dot-dot) as a path element.
+Programs should typically use <code>FileServer</code> and 
+<a href="/pkg/net/http/#Dir"><code>Dir</code></a>
+instead of calling <code>ServeFile</code> directly.
+Programs that need to serve file content in response to requests for URLs containing dot-dot can 
+still call <a href="/pkg/net/http/#ServeContent"><code>ServeContent</code></a>.
+Third, the
+<a href="/pkg/net/http/#Client"><code>Client</code></a> now allows user code to set the
 <code>Expect:</code> <code>100-continue</code> header (see
-<a href="/pkg/http/#Transport"><code>Transport.ExpectContinueTimeout</code></a>).
-Third, there are
-<a href="/pkg/net/http/#pkg-constants">four new error codes</a> from RFC 6585:
+<a href="/pkg/net/http/#Transport"><code>Transport.ExpectContinueTimeout</code></a>).
+Fourth, there are
+<a href="/pkg/net/http/#pkg-constants">five new error codes</a>:
 <code>StatusPreconditionRequired</code> (428),
 <code>StatusTooManyRequests</code> (429),
-<code>StatusRequestHeaderFieldsTooLarge</code> (431),
-and
-<code>StatusNetworkAuthenticationRequired</code> (511).
-Fourth, the implementation and documentation of
-<a href="/pkg/http/#CloseNotifier"><code>CloseNotifier</code></a>
+<code>StatusRequestHeaderFieldsTooLarge</code> (431), and
+<code>StatusNetworkAuthenticationRequired</code> (511) from RFC 6585,
+as well as the recently-approved
+<code>StatusUnavailableForLegalReasons</code> (451).
+Fifth, the implementation and documentation of
+<a href="/pkg/net/http/#CloseNotifier"><code>CloseNotifier</code></a>
 has been substantially changed.
-The <a href="/pkg/http/#Hijacker"><code>Hijacker</code></a>
+The <a href="/pkg/net/http/#Hijacker"><code>Hijacker</code></a>
 interface now works correctly on connections that have previously
 been used with <code>CloseNotifier</code>.
 The documentation now describes when <code>CloseNotifier</code>
@@ -750,17 +760,17 @@ is expected to work.
 <li>
 Also in the <a href="/pkg/net/http/"><code>net/http</code></a> package,
 there are a few changes related to the handling of a
-<a href="/pkg/http/#Request"><code>Request</code></a> data structure with its <code>Method</code> field set to the empty string.
+<a href="/pkg/net/http/#Request"><code>Request</code></a> data structure with its <code>Method</code> field set to the empty string.
 An empty <code>Method</code> field has always been documented as an alias for <code>"GET"</code>
 and it remains so.
 However, Go 1.6 fixes a few routines that did not treat an empty
 <code>Method</code> the same as an explicit <code>"GET"</code>.
 Most notably, in previous releases
-<a href="/pkg/http/#Client"><code>Client</code></a> followed redirects only with
+<a href="/pkg/net/http/#Client"><code>Client</code></a> followed redirects only with
 <code>Method</code> set explicitly to <code>"GET"</code>;
 in Go 1.6 <code>Client</code> also follows redirects for the empty <code>Method</code>.
 Finally,
-<a href="/pkg/http/#NewRequest"><code>NewRequest</code></a> accepts a <code>method</code> argument that has not been
+<a href="/pkg/net/http/#NewRequest"><code>NewRequest</code></a> accepts a <code>method</code> argument that has not been
 documented as allowed to be empty.
 In past releases, passing an empty <code>method</code> argument resulted
 in a <code>Request</code> with an empty <code>Method</code> field.
@@ -825,7 +835,7 @@ In the <a href="/pkg/os/exec/"><code>os/exec</code></a> package,
 <a href="/pkg/os/exec/#Cmd.Output"><code>Output</code></a> method continues to return an
 <a href="/pkg/os/exec/#ExitError"><code>ExitError</code></a> when a command exits with an unsuccessful status.
 If standard error would otherwise have been discarded,
-the returned <code>ExitError</code> now holds a prefix
+the returned <code>ExitError</code> now holds a prefix and suffix
 (currently 32 kB) of the failed command's standard error output,
 for debugging or for inclusion in error messages.
 The <code>ExitError</code>'s
@@ -865,16 +875,18 @@ should only be used when contention has been observed.
 <li>
 The <a href="/pkg/strconv/"><code>strconv</code></a> package adds
 <a href="/pkg/strconv/#IsGraphic"><code>IsGraphic</code></a>,
+similar to <a href="/pkg/strconv/#IsPrint"><code>IsPrint</code></a>.
+It also adds
 <a href="/pkg/strconv/#QuoteToGraphic"><code>QuoteToGraphic</code></a>,
 <a href="/pkg/strconv/#QuoteRuneToGraphic"><code>QuoteRuneToGraphic</code></a>,
 <a href="/pkg/strconv/#AppendQuoteToGraphic"><code>AppendQuoteToGraphic</code></a>,
 and
 <a href="/pkg/strconv/#AppendQuoteRuneToGraphic"><code>AppendQuoteRuneToGraphic</code></a>,
 analogous to
-<a href="/pkg/strconv/#IsPrint"><code>IsPrint</code></a>,
-<a href="/pkg/strconv/#QuoteToPrint"><code>QuoteToPrint</code></a>,
+<a href="/pkg/strconv/#QuoteToASCII"><code>QuoteToASCII</code></a>,
+<a href="/pkg/strconv/#QuoteRuneToASCII"><code>QuoteRuneToASCII</code></a>,
 and so on.
-The <code>Print</code> family escapes all space characters except ASCII space (U+0020).
+The <code>ASCII</code> family escapes all space characters except ASCII space (U+0020).
 In contrast, the <code>Graphic</code> family does not escape any Unicode space characters (category Zs).
 </li>
 

diff --git a/doc/go_faq.html b/doc/go_faq.html
index bcd12075b64c6f946e08be28aa5379c6aacc085a..b5f9772787678949edde8d7c0a089aea88d7fcf9 100644 (file)
--- a/doc/go_faq.html
+++ b/doc/go_faq.html
@@ -98,7 +98,7 @@ What's the origin of the mascot?</h3>
 <p>
 The mascot and logo were designed by
 <a href="http://reneefrench.blogspot.com">Renée French</a>, who also designed
-<a href="http://plan9.bell-labs.com/plan9/glenda.html">Glenda</a>,
+<a href="https://9p.io/plan9/glenda.html">Glenda</a>,
 the Plan 9 bunny.
 The <a href="https://blog.golang.org/gopher">gopher</a>
 is derived from one she used for an <a href="http://wfmu.org/">WFMU</a>

diff --git a/doc/install-source.html b/doc/install-source.html
index 60931ada5da91407f91d28b2ebc3f6237b41d708..332c72097ea2b6da86ad1e1664bfbffb911d7931 100644 (file)
--- a/doc/install-source.html
+++ b/doc/install-source.html
@@ -173,6 +173,21 @@ follow the instructions on the
 <a href="http://git-scm.com/downloads">Git downloads</a> page.
 </p>
 
+<h2 id="ccompiler">(Optional) Install a C compiler</h2>
+
+<p>
+To build a Go installation
+with <code><a href="/cmd/cgo">cgo</a></code> support, which permits Go
+programs to import C libraries, a C compiler such as <code>gcc</code>
+or <code>clang</code> must be installed first. Do this using whatever
+installation method is standard on the system.
+</p>
+
+<p>
+To build without <code>cgo</code>, set the environment variable
+<code>CGO_ENABLED=0</code> before running <code>all.bash</code> or
+<code>make.bash</code>.
+</p>
 
 <h2 id="fetch">Fetch the repository</h2>
 
@@ -184,7 +199,7 @@ Then clone the repository and check out the latest release tag:</p>
 <pre>
 $ git clone https://go.googlesource.com/go
 $ cd go
-$ git checkout go1.5.2
+$ git checkout go1.5.3
 </pre>
 
 <h2 id="head">(Optional) Switch to the master branch</h2>
@@ -363,7 +378,7 @@ New releases are announced on the
 <a href="//groups.google.com/group/golang-announce">golang-announce</a>
 mailing list.
 Each announcement mentions the latest release tag, for instance,
-<code>go1.5.2</code>.
+<code>go1.5.3</code>.
 </p>
 
 <p>

diff --git a/lib/time/update.bash b/lib/time/update.bash
index 3ef1df582cf2adab68dea006c0098cb7068873c0..86b1f211000b4017ecb08b7263a65747346c09bf 100755 (executable)
--- a/lib/time/update.bash
+++ b/lib/time/update.bash
@@ -5,10 +5,11 @@
 
 # This script rebuilds the time zone files using files
 # downloaded from the ICANN/IANA distribution.
+# Consult http://www.iana.org/time-zones for the latest versions.
 
 # Versions to use.
-CODE=2015e
-DATA=2015e
+CODE=2016a
+DATA=2016a
 
 set -e
 rm -rf work

diff --git a/lib/time/zoneinfo.zip b/lib/time/zoneinfo.zip
index 73c30b45970f489c9b8b7bea0f1ccdfa958b5d49..0207d6bcbc6a1edc4372b2d4737a108344982866 100644 (file)
Binary files a/lib/time/zoneinfo.zip and b/lib/time/zoneinfo.zip differ

diff --git a/misc/cgo/errors/ptr.go b/misc/cgo/errors/ptr.go
index 0dd291f5ed132e17d868208b3c104d24400d14de..834cde9199175de2df55b3223bc4ff4f549c0394 100644 (file)
--- a/misc/cgo/errors/ptr.go
+++ b/misc/cgo/errors/ptr.go
@@ -27,10 +27,16 @@ type ptrTest struct {
        imports   []string // a list of imports
        support   string   // supporting functions
        body      string   // the body of the main function
+       extra     []extra  // extra files
        fail      bool     // whether the test should fail
        expensive bool     // whether the test requires the expensive check
 }
 
+type extra struct {
+       name     string
+       contents string
+}
+
 var ptrTests = []ptrTest{
        {
                // Passing a pointer to a struct that contains a Go pointer.
@@ -237,6 +243,43 @@ var ptrTests = []ptrTest{
                           func GoFn() *byte { return (*byte)(C.malloc(1)) }`,
                body: `C.GoFn()`,
        },
+       {
+               // Passing a Go string is fine.
+               name: "pass-string",
+               c: `#include <stddef.h>
+                    typedef struct { const char *p; ptrdiff_t n; } gostring;
+                    gostring f(gostring s) { return s; }`,
+               imports: []string{"unsafe"},
+               body:    `s := "a"; r := C.f(*(*C.gostring)(unsafe.Pointer(&s))); if *(*string)(unsafe.Pointer(&r)) != s { panic(r) }`,
+       },
+       {
+               // Passing a slice of Go strings fails.
+               name:    "pass-string-slice",
+               c:       `void f(void *p) {}`,
+               imports: []string{"strings", "unsafe"},
+               support: `type S struct { a [1]string }`,
+               body:    `s := S{a:[1]string{strings.Repeat("a", 2)}}; C.f(unsafe.Pointer(&s.a[0]))`,
+               fail:    true,
+       },
+       {
+               // Exported functions may not return strings.
+               name:    "ret-string",
+               c:       `extern void f();`,
+               imports: []string{"strings"},
+               support: `//export GoStr
+                          func GoStr() string { return strings.Repeat("a", 2) }`,
+               body: `C.f()`,
+               extra: []extra{
+                       {
+                               "call.c",
+                               `#include <stddef.h>
+                                 typedef struct { const char *p; ptrdiff_t n; } gostring;
+                                 extern gostring GoStr();
+                                 void f() { GoStr(); }`,
+                       },
+               },
+               fail: true,
+       },
 }
 
 func main() {
@@ -244,12 +287,17 @@ func main() {
 }
 
 func doTests() int {
-       dir, err := ioutil.TempDir("", "cgoerrors")
+       gopath, err := ioutil.TempDir("", "cgoerrors")
        if err != nil {
                fmt.Fprintln(os.Stderr, err)
                return 2
        }
-       defer os.RemoveAll(dir)
+       defer os.RemoveAll(gopath)
+
+       if err := os.MkdirAll(filepath.Join(gopath, "src"), 0777); err != nil {
+               fmt.Fprintln(os.Stderr, err)
+               return 2
+       }
 
        workers := runtime.NumCPU() + 1
 
@@ -259,7 +307,7 @@ func doTests() int {
        for i := 0; i < workers; i++ {
                wg.Add(1)
                go func() {
-                       worker(dir, c, errs)
+                       worker(gopath, c, errs)
                        wg.Done()
                }()
        }
@@ -281,10 +329,10 @@ func doTests() int {
        return tot
 }
 
-func worker(dir string, c, errs chan int) {
+func worker(gopath string, c, errs chan int) {
        e := 0
        for i := range c {
-               if !doOne(dir, i) {
+               if !doOne(gopath, i) {
                        e++
                }
        }
@@ -293,9 +341,15 @@ func worker(dir string, c, errs chan int) {
        }
 }
 
-func doOne(dir string, i int) bool {
+func doOne(gopath string, i int) bool {
        t := &ptrTests[i]
 
+       dir := filepath.Join(gopath, "src", fmt.Sprintf("dir%d", i))
+       if err := os.Mkdir(dir, 0777); err != nil {
+               fmt.Fprintln(os.Stderr, err)
+               return false
+       }
+
        name := filepath.Join(dir, fmt.Sprintf("t%d.go", i))
        f, err := os.Create(name)
        if err != nil {
@@ -330,13 +384,30 @@ func doOne(dir string, i int) bool {
                return false
        }
        if err := f.Close(); err != nil {
-               fmt.Fprintln(os.Stderr, "closing %s: %v\n", name, err)
+               fmt.Fprintf(os.Stderr, "closing %s: %v\n", name, err)
                return false
        }
 
+       for _, e := range t.extra {
+               if err := ioutil.WriteFile(filepath.Join(dir, e.name), []byte(e.contents), 0644); err != nil {
+                       fmt.Fprintf(os.Stderr, "writing %s: %v\n", e.name, err)
+                       return false
+               }
+       }
+
        ok := true
 
-       cmd := exec.Command("go", "run", name)
+       cmd := exec.Command("go", "build")
+       cmd.Dir = dir
+       cmd.Env = addEnv("GOPATH", gopath)
+       buf, err := cmd.CombinedOutput()
+       if err != nil {
+               fmt.Fprintf(os.Stderr, "test %s failed to build: %v\n%s", t.name, err, buf)
+               return false
+       }
+
+       exe := filepath.Join(dir, filepath.Base(dir))
+       cmd = exec.Command(exe)
        cmd.Dir = dir
 
        if t.expensive {
@@ -354,7 +425,7 @@ func doOne(dir string, i int) bool {
                        ok = false
                }
 
-               cmd = exec.Command("go", "run", name)
+               cmd = exec.Command(exe)
                cmd.Dir = dir
        }
 
@@ -362,7 +433,7 @@ func doOne(dir string, i int) bool {
                cmd.Env = cgocheckEnv("2")
        }
 
-       buf, err := cmd.CombinedOutput()
+       buf, err = cmd.CombinedOutput()
 
        if t.fail {
                if err == nil {
@@ -389,7 +460,7 @@ func doOne(dir string, i int) bool {
 
                if !t.expensive && ok {
                        // Make sure it passes with the expensive checks.
-                       cmd := exec.Command("go", "run", name)
+                       cmd := exec.Command(exe)
                        cmd.Dir = dir
                        cmd.Env = cgocheckEnv("2")
                        buf, err := cmd.CombinedOutput()
@@ -404,7 +475,7 @@ func doOne(dir string, i int) bool {
        }
 
        if t.fail && ok {
-               cmd = exec.Command("go", "run", name)
+               cmd = exec.Command(exe)
                cmd.Dir = dir
                cmd.Env = cgocheckEnv("0")
                buf, err := cmd.CombinedOutput()
@@ -427,9 +498,14 @@ func reportTestOutput(w io.Writer, name string, buf []byte) {
 }
 
 func cgocheckEnv(val string) []string {
-       env := []string{"GODEBUG=cgocheck=" + val}
+       return addEnv("GODEBUG", "cgocheck="+val)
+}
+
+func addEnv(key, val string) []string {
+       env := []string{key + "=" + val}
+       look := key + "="
        for _, e := range os.Environ() {
-               if !strings.HasPrefix(e, "GODEBUG=") {
+               if !strings.HasPrefix(e, look) {
                        env = append(env, e)
                }
        }

diff --git a/misc/cgo/test/sigaltstack.go b/misc/cgo/test/sigaltstack.go
index 787653c4825ee61c1e14722327ddd7bfd1db9024..b641ff60374142411ef93889beab410c4f6bffd2 100644 (file)
--- a/misc/cgo/test/sigaltstack.go
+++ b/misc/cgo/test/sigaltstack.go
@@ -30,7 +30,7 @@ static void changeSignalStack() {
 }
 
 static void restoreSignalStack() {
-#if defined(__x86_64__) && defined(__APPLE__)
+#if (defined(__x86_64__) || defined(__i386__)) && defined(__APPLE__)
        // The Darwin C library enforces a minimum that the kernel does not.
        // This is OK since we allocated this much space in mpreinit,
        // it was just removed from the buffer by stackalloc.
@@ -57,6 +57,8 @@ func testSigaltstack(t *testing.T) {
        switch {
        case runtime.GOOS == "solaris", runtime.GOOS == "darwin" && (runtime.GOARCH == "arm" || runtime.GOARCH == "arm64"):
                t.Skipf("switching signal stack not implemented on %s/%s", runtime.GOOS, runtime.GOARCH)
+       case runtime.GOOS == "darwin" && runtime.GOARCH == "386":
+               t.Skipf("sigaltstack fails on darwin/386")
        }
 
        C.changeSignalStack()

diff --git a/misc/cgo/testcarchive/test.bash b/misc/cgo/testcarchive/test.bash
index f4b4a3079fe1f06f6f5a401538ea35b4f9ff8363..f4e7c458ec670f50f2fefce688fc98702c6f8230 100755 (executable)
--- a/misc/cgo/testcarchive/test.bash
+++ b/misc/cgo/testcarchive/test.bash
@@ -85,4 +85,22 @@ if ! $bin; then
 fi
 rm -rf libgo4.a libgo4.h testp pkg
 
+rm -f testar
+cat >testar <<EOF
+#!/usr/bin/env bash
+while expr \$1 : '[-]' >/dev/null; do
+  shift
+done
+echo "testar" > \$1
+echo "testar" > $(pwd)/testar.ran
+EOF
+chmod +x testar
+rm -f testar.ran
+GOPATH=$(pwd) go build -buildmode=c-archive -ldflags=-extar=$(pwd)/testar -o libgo4.a libgo4
+if ! test -f testar.ran; then
+    echo "FAIL test5"
+    status=1
+fi
+rm -rf libgo4.a libgo4.h testar testar.ran pkg
+
 exit $status

diff --git a/misc/cgo/testshared/shared_test.go b/misc/cgo/testshared/shared_test.go
index 592a91715e7114dab7ed9a6aca08a71f50150aab..86fb530167de0a88339fed2cc816383bef36f186 100644 (file)
--- a/misc/cgo/testshared/shared_test.go
+++ b/misc/cgo/testshared/shared_test.go
@@ -749,3 +749,15 @@ func TestABIChecking(t *testing.T) {
        goCmd(t, "install", "-buildmode=shared", "-linkshared", "dep")
        run(t, "after non-ABI breaking change", "./bin/exe")
 }
+
+// If a package 'explicit' imports a package 'implicit', building
+// 'explicit' into a shared library implicitly includes implicit in
+// the shared library. Building an executable that imports both
+// explicit and implicit builds the code from implicit into the
+// executable rather than fetching it from the shared library. The
+// link still succeeds and the executable still runs though.
+func TestImplicitInclusion(t *testing.T) {
+       goCmd(t, "install", "-buildmode=shared", "-linkshared", "explicit")
+       goCmd(t, "install", "-linkshared", "implicitcmd")
+       run(t, "running executable linked against library that contains same package as it", "./bin/implicitcmd")
+}

diff --git a/misc/cgo/testshared/src/explicit/explicit.go b/misc/cgo/testshared/src/explicit/explicit.go
new file mode 100644 (file)
index 0000000..6a4453f
--- /dev/null
+++ b/misc/cgo/testshared/src/explicit/explicit.go
@@ -0,0 +1,9 @@
+package explicit
+
+import (
+       "implicit"
+)
+
+func E() int {
+       return implicit.I()
+}

diff --git a/misc/cgo/testshared/src/implicit/implicit.go b/misc/cgo/testshared/src/implicit/implicit.go
new file mode 100644 (file)
index 0000000..5360188
--- /dev/null
+++ b/misc/cgo/testshared/src/implicit/implicit.go
@@ -0,0 +1,5 @@
+package implicit
+
+func I() int {
+       return 42
+}

diff --git a/misc/cgo/testshared/src/implicitcmd/implicitcmd.go b/misc/cgo/testshared/src/implicitcmd/implicitcmd.go
new file mode 100644 (file)
index 0000000..f611293
--- /dev/null
+++ b/misc/cgo/testshared/src/implicitcmd/implicitcmd.go
@@ -0,0 +1,10 @@
+package main
+
+import (
+       "explicit"
+       "implicit"
+)
+
+func main() {
+       println(implicit.I() + explicit.E())
+}

diff --git a/src/archive/zip/example_test.go b/src/archive/zip/example_test.go
index 8dd79cc79c823f38b959621a0d194d008e38ae4d..1eed3040cb0c6c6df877a7704351ca5af4af3ef4 100644 (file)
--- a/src/archive/zip/example_test.go
+++ b/src/archive/zip/example_test.go
@@ -76,8 +76,7 @@ func ExampleReader() {
 }
 
 func ExampleWriter_RegisterCompressor() {
-       // Override the default Deflate compressor with a higher compression
-       // level.
+       // Override the default Deflate compressor with a higher compression level.
 
        // Create a buffer to write our archive to.
        buf := new(bytes.Buffer)
@@ -85,19 +84,9 @@ func ExampleWriter_RegisterCompressor() {
        // Create a new zip archive.
        w := zip.NewWriter(buf)
 
-       var fw *flate.Writer
-
-       // Register the deflator.
+       // Register a custom Deflate compressor.
        w.RegisterCompressor(zip.Deflate, func(out io.Writer) (io.WriteCloser, error) {
-               var err error
-               if fw == nil {
-                       // Creating a flate compressor for every file is
-                       // expensive, create one and reuse it.
-                       fw, err = flate.NewWriter(out, flate.BestCompression)
-               } else {
-                       fw.Reset(out)
-               }
-               return fw, err
+               return flate.NewWriter(out, flate.BestCompression)
        })
 
        // Proceed to add files to w.

diff --git a/src/archive/zip/reader.go b/src/archive/zip/reader.go
index 9a0e20db1e19c6f2c50c9c6e8d7387485828f2bd..10e81728757d3933736b8cc52cff24c0b880f0bb 100644 (file)
--- a/src/archive/zip/reader.go
+++ b/src/archive/zip/reader.go
@@ -118,8 +118,6 @@ func (z *Reader) init(r io.ReaderAt, size int64) error {
 // RegisterDecompressor registers or overrides a custom decompressor for a
 // specific method ID. If a decompressor for a given method is not found,
 // Reader will default to looking up the decompressor at the package level.
-//
-// Must not be called concurrently with Open on any Files in the Reader.
 func (z *Reader) RegisterDecompressor(method uint16, dcomp Decompressor) {
        if z.decompressors == nil {
                z.decompressors = make(map[uint16]Decompressor)
@@ -332,7 +330,17 @@ func readDirectoryHeader(f *File, r io.Reader) error {
                }
        }
 
-       if needUSize || needCSize || needHeaderOffset {
+       // Assume that uncompressed size 2³²-1 could plausibly happen in
+       // an old zip32 file that was sharding inputs into the largest chunks
+       // possible (or is just malicious; search the web for 42.zip).
+       // If needUSize is true still, it means we didn't see a zip64 extension.
+       // As long as the compressed size is not also 2³²-1 (implausible)
+       // and the header is not also 2³²-1 (equally implausible),
+       // accept the uncompressed size 2³²-1 as valid.
+       // If nothing else, this keeps archive/zip working with 42.zip.
+       _ = needUSize
+
+       if needCSize || needHeaderOffset {
                return ErrFormat
        }
 

diff --git a/src/archive/zip/reader_test.go b/src/archive/zip/reader_test.go
index 8f7e8bf555d31cdb12f62cbc4aa2fb9f48d88ccc..72cf5d9cf42f09fc89c8a567cc9c5803603ba5b5 100644 (file)
--- a/src/archive/zip/reader_test.go
+++ b/src/archive/zip/reader_test.go
@@ -27,12 +27,24 @@ type ZipTest struct {
 }
 
 type ZipTestFile struct {
-       Name       string
-       Content    []byte // if blank, will attempt to compare against File
+       Name  string
+       Mode  os.FileMode
+       Mtime string // optional, modified time in format "mm-dd-yy hh:mm:ss"
+
+       // Information describing expected zip file content.
+       // First, reading the entire content should produce the error ContentErr.
+       // Second, if ContentErr==nil, the content should match Content.
+       // If content is large, an alternative to setting Content is to set File,
+       // which names a file in the testdata/ directory containing the
+       // uncompressed expected content.
+       // If content is very large, an alternative to setting Content or File
+       // is to set Size, which will then be checked against the header-reported size
+       // but will bypass the decompressing of the actual data.
+       // This last option is used for testing very large (multi-GB) compressed files.
        ContentErr error
-       File       string // name of file to compare to (relative to testdata/)
-       Mtime      string // modified time in format "mm-dd-yy hh:mm:ss"
-       Mode       os.FileMode
+       Content    []byte
+       File       string
+       Size       uint64
 }
 
 // Caution: The Mtime values found for the test files should correspond to
@@ -248,6 +260,19 @@ var tests = []ZipTest{
                        },
                },
        },
+       // Largest possible non-zip64 file, with no zip64 header.
+       {
+               Name:   "big.zip",
+               Source: returnBigZipBytes,
+               File: []ZipTestFile{
+                       {
+                               Name:    "big.file",
+                               Content: nil,
+                               Size:    1<<32 - 1,
+                               Mode:    0666,
+                       },
+               },
+       },
 }
 
 var crossPlatform = []ZipTestFile{
@@ -356,13 +381,31 @@ func readTestFile(t *testing.T, zt ZipTest, ft ZipTestFile, f *File) {
 
        testFileMode(t, zt.Name, f, ft.Mode)
 
-       var b bytes.Buffer
+       size := uint64(f.UncompressedSize)
+       if size == uint32max {
+               size = f.UncompressedSize64
+       } else if size != f.UncompressedSize64 {
+               t.Errorf("%v: UncompressedSize=%#x does not match UncompressedSize64=%#x", f.Name, size, f.UncompressedSize64)
+       }
+
        r, err := f.Open()
        if err != nil {
                t.Errorf("%s: %v", zt.Name, err)
                return
        }
 
+       // For very large files, just check that the size is correct.
+       // The content is expected to be all zeros.
+       // Don't bother uncompressing: too big.
+       if ft.Content == nil && ft.File == "" && ft.Size > 0 {
+               if size != ft.Size {
+                       t.Errorf("%v: uncompressed size %#x, want %#x", size, ft.Size)
+               }
+               r.Close()
+               return
+       }
+
+       var b bytes.Buffer
        _, err = io.Copy(&b, r)
        if err != ft.ContentErr {
                t.Errorf("%s: copying contents: %v (want %v)", zt.Name, err, ft.ContentErr)
@@ -372,10 +415,6 @@ func readTestFile(t *testing.T, zt ZipTest, ft ZipTestFile, f *File) {
        }
        r.Close()
 
-       size := uint64(f.UncompressedSize)
-       if size == uint32max {
-               size = f.UncompressedSize64
-       }
        if g := uint64(b.Len()); g != size {
                t.Errorf("%v: read %v bytes but f.UncompressedSize == %v", f.Name, g, size)
        }
@@ -510,6 +549,182 @@ func returnRecursiveZip() (r io.ReaderAt, size int64) {
        return bytes.NewReader(b), int64(len(b))
 }
 
+// biggestZipBytes returns the bytes of a zip file biggest.zip
+// that contains a zip file bigger.zip that contains a zip file
+// big.zip that contains big.file, which contains 2³²-1 zeros.
+// The big.zip file is interesting because it has no zip64 header,
+// much like the innermost zip files in the well-known 42.zip.
+//
+// biggest.zip was generated by changing isZip64 to use > uint32max
+// instead of >= uint32max and then running this program:
+//
+//     package main
+//
+//     import (
+//             "archive/zip"
+//             "bytes"
+//             "io"
+//             "io/ioutil"
+//             "log"
+//     )
+//
+//     type zeros struct{}
+//
+//     func (zeros) Read(b []byte) (int, error) {
+//             for i := range b {
+//                     b[i] = 0
+//             }
+//             return len(b), nil
+//     }
+//
+//     func main() {
+//             bigZip := makeZip("big.file", io.LimitReader(zeros{}, 1<<32-1))
+//             if err := ioutil.WriteFile("/tmp/big.zip", bigZip, 0666); err != nil {
+//                     log.Fatal(err)
+//             }
+//
+//             biggerZip := makeZip("big.zip", bytes.NewReader(bigZip))
+//             if err := ioutil.WriteFile("/tmp/bigger.zip", biggerZip, 0666); err != nil {
+//                     log.Fatal(err)
+//             }
+//
+//             biggestZip := makeZip("bigger.zip", bytes.NewReader(biggerZip))
+//             if err := ioutil.WriteFile("/tmp/biggest.zip", biggestZip, 0666); err != nil {
+//                     log.Fatal(err)
+//             }
+//     }
+//
+//     func makeZip(name string, r io.Reader) []byte {
+//             var buf bytes.Buffer
+//             w := zip.NewWriter(&buf)
+//             wf, err := w.Create(name)
+//             if err != nil {
+//                     log.Fatal(err)
+//             }
+//             if _, err = io.Copy(wf, r); err != nil {
+//                     log.Fatal(err)
+//             }
+//             if err := w.Close(); err != nil {
+//                     log.Fatal(err)
+//             }
+//             return buf.Bytes()
+//     }
+//
+// The 4 GB of zeros compresses to 4 MB, which compresses to 20 kB,
+// which compresses to 1252 bytes (in the hex dump below).
+//
+// It's here in hex for the same reason as rZipBytes above: to avoid
+// problems with on-disk virus scanners or other zip processors.
+//
+func biggestZipBytes() []byte {
+       s := `
+0000000 50 4b 03 04 14 00 08 00 08 00 00 00 00 00 00 00
+0000010 00 00 00 00 00 00 00 00 00 00 0a 00 00 00 62 69
+0000020 67 67 65 72 2e 7a 69 70 ec dc 6b 4c 53 67 18 07
+0000030 f0 16 c5 ca 65 2e cb b8 94 20 61 1f 44 33 c7 cd
+0000040 c0 86 4a b5 c0 62 8a 61 05 c6 cd 91 b2 54 8c 1b
+0000050 63 8b 03 9c 1b 95 52 5a e3 a0 19 6c b2 05 59 44
+0000060 64 9d 73 83 71 11 46 61 14 b9 1d 14 09 4a c3 60
+0000070 2e 4c 6e a5 60 45 02 62 81 95 b6 94 9e 9e 77 e7
+0000080 d0 43 b6 f8 71 df 96 3c e7 a4 69 ce bf cf e9 79
+0000090 ce ef 79 3f bf f1 31 db b6 bb 31 76 92 e7 f3 07
+00000a0 8b fc 9c ca cc 08 cc cb cc 5e d2 1c 88 d9 7e bb
+00000b0 4f bb 3a 3f 75 f1 5d 7f 8f c2 68 67 77 8f 25 ff
+00000c0 84 e2 93 2d ef a4 95 3d 71 4e 2c b9 b0 87 c3 be
+00000d0 3d f8 a7 60 24 61 c5 ef ae 9e c8 6c 6d 4e 69 c8
+00000e0 67 65 34 f8 37 76 2d 76 5c 54 f3 95 65 49 c7 0f
+00000f0 18 71 4b 7e 5b 6a d1 79 47 61 41 b0 4e 2a 74 45
+0000100 43 58 12 b2 5a a5 c6 7d 68 55 88 d4 98 75 18 6d
+0000110 08 d1 1f 8f 5a 9e 96 ee 45 cf a4 84 4e 4b e8 50
+0000120 a7 13 d9 06 de 52 81 97 36 b2 d7 b8 fc 2b 5f 55
+0000130 23 1f 32 59 cf 30 27 fb e2 8a b9 de 45 dd 63 9c
+0000140 4b b5 8b 96 4c 7a 62 62 cc a1 a7 cf fa f1 fe dd
+0000150 54 62 11 bf 36 78 b3 c7 b1 b5 f2 61 4d 4e dd 66
+0000160 32 2e e6 70 34 5f f4 c9 e6 6c 43 6f da 6b c6 c3
+0000170 09 2c ce 09 57 7f d2 7e b4 23 ba 7c 1b 99 bc 22
+0000180 3e f1 de 91 2f e3 9c 1b 82 cc c2 84 39 aa e6 de
+0000190 b4 69 fc cc cb 72 a6 61 45 f0 d3 1d 26 19 7c 8d
+00001a0 29 c8 66 02 be 77 6a f9 3d 34 79 17 19 c8 96 24
+00001b0 a3 ac e4 dd 3b 1a 8e c6 fe 96 38 6b bf 67 5a 23
+00001c0 f4 16 f4 e6 8a b4 fc c2 cd bf 95 66 1d bb 35 aa
+00001d0 92 7d 66 d8 08 8d a5 1f 54 2a af 09 cf 61 ff d2
+00001e0 85 9d 8f b6 d7 88 07 4a 86 03 db 64 f3 d9 92 73
+00001f0 df ec a7 fc 23 4c 8d 83 79 63 2a d9 fd 8d b3 c8
+0000200 8f 7e d4 19 85 e6 8d 1c 76 f0 8b 58 32 fd 9a d6
+0000210 85 e2 48 ad c3 d5 60 6f 7e 22 dd ef 09 49 7c 7f
+0000220 3a 45 c3 71 b7 df f3 4c 63 fb b5 d9 31 5f 6e d6
+0000230 24 1d a4 4a fe 32 a7 5c 16 48 5c 3e 08 6b 8a d3
+0000240 25 1d a2 12 a5 59 24 ea 20 5f 52 6d ad 94 db 6b
+0000250 94 b9 5d eb 4b a7 5c 44 bb 1e f2 3c 6b cf 52 c9
+0000260 e9 e5 ba 06 b9 c4 e5 0a d0 00 0d d0 00 0d d0 00
+0000270 0d d0 00 0d d0 00 0d d0 00 0d d0 00 0d d0 00 0d
+0000280 d0 00 0d d0 00 0d d0 00 0d d0 00 0d d0 00 0d d0
+0000290 00 0d d0 00 0d d0 00 0d d0 00 0d d0 00 0d d0 00
+00002a0 0d d0 00 cd ff 9e 46 86 fa a7 7d 3a 43 d7 8e 10
+00002b0 52 e9 be e6 6e cf eb 9e 85 4d 65 ce cc 30 c1 44
+00002c0 c0 4e af bc 9c 6c 4b a0 d7 54 ff 1d d5 5c 89 fb
+00002d0 b5 34 7e c4 c2 9e f5 a0 f6 5b 7e 6e ca 73 c7 ef
+00002e0 5d be de f9 e8 81 eb a5 0a a5 63 54 2c d7 1c d1
+00002f0 89 17 85 f8 16 94 f2 8a b2 a3 f5 b6 6d df 75 cd
+0000300 90 dd 64 bd 5d 55 4e f2 55 19 1b b7 cc ef 1b ea
+0000310 2e 05 9c f4 aa 1e a8 cd a6 82 c7 59 0f 5e 9d e0
+0000320 bb fc 6c d6 99 23 eb 36 ad c6 c5 e1 d8 e1 e2 3e
+0000330 d9 90 5a f7 91 5d 6f bc 33 6d 98 47 d2 7c 2e 2f
+0000340 99 a4 25 72 85 49 2c be 0b 5b af 8f e5 6e 81 a6
+0000350 a3 5a 6f 39 53 3a ab 7a 8b 1e 26 f7 46 6c 7d 26
+0000360 53 b3 22 31 94 d3 83 f2 18 4d f5 92 33 27 53 97
+0000370 0f d3 e6 55 9c a6 c5 31 87 6f d3 f3 ae 39 6f 56
+0000380 10 7b ab 7e d0 b4 ca f2 b8 05 be 3f 0e 6e 5a 75
+0000390 ab 0c f5 37 0e ba 8e 75 71 7a aa ed 7a dd 6a 63
+00003a0 be 9b a0 97 27 6a 6f e7 d3 8b c4 7c ec d3 91 56
+00003b0 d9 ac 5e bf 16 42 2f 00 1f 93 a2 23 87 bd e2 59
+00003c0 a0 de 1a 66 c8 62 eb 55 8f 91 17 b4 61 42 7a 50
+00003d0 40 03 34 40 03 34 40 03 34 40 03 34 40 03 34 40
+00003e0 03 34 40 03 34 40 03 34 40 03 34 40 03 34 40 03
+00003f0 34 40 03 34 40 03 34 ff 85 86 90 8b ea 67 90 0d
+0000400 e1 42 1b d2 61 d6 79 ec fd 3e 44 28 a4 51 6c 5c
+0000410 fc d2 72 ca ba 82 18 46 16 61 cd 93 a9 0f d1 24
+0000420 17 99 e2 2c 71 16 84 0c c8 7a 13 0f 9a 5e c5 f0
+0000430 79 64 e2 12 4d c8 82 a1 81 19 2d aa 44 6d 87 54
+0000440 84 71 c1 f6 d4 ca 25 8c 77 b9 08 c7 c8 5e 10 8a
+0000450 8f 61 ed 8c ba 30 1f 79 9a c7 60 34 2b b9 8c f8
+0000460 18 a6 83 1b e3 9f ad 79 fe fd 1b 8b f1 fc 41 6f
+0000470 d4 13 1f e3 b8 83 ba 64 92 e7 eb e4 77 05 8f ba
+0000480 fa 3b 00 00 ff ff 50 4b 07 08 a6 18 b1 91 5e 04
+0000490 00 00 e4 47 00 00 50 4b 01 02 14 00 14 00 08 00
+00004a0 08 00 00 00 00 00 a6 18 b1 91 5e 04 00 00 e4 47
+00004b0 00 00 0a 00 00 00 00 00 00 00 00 00 00 00 00 00
+00004c0 00 00 00 00 62 69 67 67 65 72 2e 7a 69 70 50 4b
+00004d0 05 06 00 00 00 00 01 00 01 00 38 00 00 00 96 04
+00004e0 00 00 00 00`
+       s = regexp.MustCompile(`[0-9a-f]{7}`).ReplaceAllString(s, "")
+       s = regexp.MustCompile(`\s+`).ReplaceAllString(s, "")
+       b, err := hex.DecodeString(s)
+       if err != nil {
+               panic(err)
+       }
+       return b
+}
+
+func returnBigZipBytes() (r io.ReaderAt, size int64) {
+       b := biggestZipBytes()
+       for i := 0; i < 2; i++ {
+               r, err := NewReader(bytes.NewReader(b), int64(len(b)))
+               if err != nil {
+                       panic(err)
+               }
+               f, err := r.File[0].Open()
+               if err != nil {
+                       panic(err)
+               }
+               b, err = ioutil.ReadAll(f)
+               if err != nil {
+                       panic(err)
+               }
+       }
+       return bytes.NewReader(b), int64(len(b))
+}
+
 func TestIssue8186(t *testing.T) {
        // Directory headers & data found in the TOC of a JAR file.
        dirEnts := []string{

diff --git a/src/archive/zip/register.go b/src/archive/zip/register.go
index 4211ec7af7ba8ee56c5dcd194959230c5a000e07..8fccbf7ca09992e0188e5cf21e98bc173376a4c6 100644 (file)
--- a/src/archive/zip/register.go
+++ b/src/archive/zip/register.go
@@ -12,15 +12,19 @@ import (
        "sync"
 )
 
-// A Compressor returns a compressing writer, writing to the
-// provided writer. On Close, any pending data should be flushed.
-type Compressor func(io.Writer) (io.WriteCloser, error)
-
-// Decompressor is a function that wraps a Reader with a decompressing Reader.
-// The decompressed ReadCloser is returned to callers who open files from
-// within the archive.  These callers are responsible for closing this reader
-// when they're finished reading.
-type Decompressor func(io.Reader) io.ReadCloser
+// A Compressor returns a new compressing writer, writing to w.
+// The WriteCloser's Close method must be used to flush pending data to w.
+// The Compressor itself must be safe to invoke from multiple goroutines
+// simultaneously, but each returned writer will be used only by
+// one goroutine at a time.
+type Compressor func(w io.Writer) (io.WriteCloser, error)
+
+// A Decompressor returns a new decompressing reader, reading from r.
+// The ReadCloser's Close method must be used to release associated resources.
+// The Decompressor itself must be safe to invoke from multiple goroutines
+// simultaneously, but each returned reader will be used only by
+// one goroutine at a time.
+type Decompressor func(r io.Reader) io.ReadCloser
 
 var flateWriterPool sync.Pool
 
@@ -75,14 +79,15 @@ var (
 )
 
 // RegisterDecompressor allows custom decompressors for a specified method ID.
-func RegisterDecompressor(method uint16, d Decompressor) {
+// The common methods Store and Deflate are built in.
+func RegisterDecompressor(method uint16, dcomp Decompressor) {
        mu.Lock()
        defer mu.Unlock()
 
        if _, ok := decompressors[method]; ok {
                panic("decompressor already registered")
        }
-       decompressors[method] = d
+       decompressors[method] = dcomp
 }
 
 // RegisterCompressor registers custom compressors for a specified method ID.

diff --git a/src/cmd/asm/internal/arch/arch.go b/src/cmd/asm/internal/arch/arch.go
index b6a51a837c07d5dedfafb9d7924144d9135f2ea1..c14a13cdb13fa1955b6015752142117e94c4575e 100644 (file)
--- a/src/cmd/asm/internal/arch/arch.go
+++ b/src/cmd/asm/internal/arch/arch.go
@@ -162,11 +162,11 @@ func archX86(linkArch *obj.LinkArch) *Arch {
        instructions["MOVDQ2Q"] = x86.AMOVQ
        instructions["MOVNTDQ"] = x86.AMOVNTO
        instructions["MOVOA"] = x86.AMOVO
-       instructions["MOVOA"] = x86.AMOVO
        instructions["PF2ID"] = x86.APF2IL
        instructions["PI2FD"] = x86.API2FL
        instructions["PSLLDQ"] = x86.APSLLO
        instructions["PSRLDQ"] = x86.APSRLO
+       instructions["PADDD"] = x86.APADDL
 
        return &Arch{
                LinkArch:       linkArch,

diff --git a/src/cmd/asm/internal/arch/arm.go b/src/cmd/asm/internal/arch/arm.go
index 8df994e8d19ee7a8d2835ca3abee6939f054bbf2..502a906a4edec1e4b04e4b56d9a3befb581744c0 100644 (file)
--- a/src/cmd/asm/internal/arch/arm.go
+++ b/src/cmd/asm/internal/arch/arm.go
@@ -62,6 +62,7 @@ var armSCOND = map[string]uint8{
 var armJump = map[string]bool{
        "B":    true,
        "BL":   true,
+       "BX":   true,
        "BEQ":  true,
        "BNE":  true,
        "BCS":  true,

diff --git a/src/cmd/asm/internal/asm/asm.go b/src/cmd/asm/internal/asm/asm.go
index 9da3664db1288e04abcba783eae6d8e5c3a5a9f8..9827d70ae19e2145f2e9c27c3c9de6d2b3814361 100644 (file)
--- a/src/cmd/asm/internal/asm/asm.go
+++ b/src/cmd/asm/internal/asm/asm.go
@@ -63,7 +63,7 @@ func (p *Parser) append(prog *obj.Prog, cond string, doLabel bool) {
                fmt.Println(p.histLineNum, prog)
        }
        if testOut != nil {
-               fmt.Fprintln(testOut, p.histLineNum, prog)
+               fmt.Fprintln(testOut, prog)
        }
 }
 

diff --git a/src/cmd/asm/internal/asm/endtoend_test.go b/src/cmd/asm/internal/asm/endtoend_test.go
index 6e339ad0b5756bba5e657d744b979a133895ae93..4bc7e2fb7493e3602dcfaad45053c788f2ac2adc 100644 (file)
--- a/src/cmd/asm/internal/asm/endtoend_test.go
+++ b/src/cmd/asm/internal/asm/endtoend_test.go
@@ -8,9 +8,11 @@ import (
        "bytes"
        "fmt"
        "io/ioutil"
-       "log"
        "os"
        "path/filepath"
+       "regexp"
+       "sort"
+       "strconv"
        "strings"
        "testing"
 
@@ -22,74 +24,368 @@ import (
 // Output is generated by, in effect, turning on -S and comparing the
 // result against a golden file.
 
-func testEndToEnd(t *testing.T, goarch string) {
+func testEndToEnd(t *testing.T, goarch, file string) {
        lex.InitHist()
-       input := filepath.Join("testdata", goarch+".s")
-       output := filepath.Join("testdata", goarch+".out")
+       input := filepath.Join("testdata", file+".s")
        architecture, ctxt := setArch(goarch)
        lexer := lex.NewLexer(input, ctxt)
        parser := NewParser(ctxt, architecture, lexer)
        pList := obj.Linknewplist(ctxt)
        var ok bool
-       testOut = new(bytes.Buffer) // The assembler writes -S output to this buffer.
+       testOut = new(bytes.Buffer) // The assembler writes test output to this buffer.
        ctxt.Bso = obj.Binitw(os.Stdout)
        defer ctxt.Bso.Flush()
-       ctxt.Diag = log.Fatalf
-       obj.Binitw(ioutil.Discard)
+       failed := false
+       ctxt.DiagFunc = func(format string, args ...interface{}) {
+               failed = true
+               t.Errorf(format, args...)
+       }
        pList.Firstpc, ok = parser.Parse()
-       if !ok {
-               t.Fatalf("asm: %s assembly failed", goarch)
+       if !ok || failed {
+               t.Errorf("asm: %s assembly failed", goarch)
+               return
        }
-       result := string(testOut.Bytes())
-       expect, err := ioutil.ReadFile(output)
-       // For Windows.
-       result = strings.Replace(result, `testdata\`, `testdata/`, -1)
+       output := strings.Split(testOut.String(), "\n")
+
+       // Reconstruct expected output by independently "parsing" the input.
+       data, err := ioutil.ReadFile(input)
        if err != nil {
-               t.Fatal(err)
-       }
-       if result != string(expect) {
-               if false { // Enable to capture output.
-                       fmt.Printf("%s", result)
-                       os.Exit(1)
-               }
-               t.Errorf("%s failed: output differs", goarch)
-               r := strings.Split(result, "\n")
-               e := strings.Split(string(expect), "\n")
-               if len(r) != len(e) {
-                       t.Errorf("%s: expected %d lines, got %d", goarch, len(e), len(r))
-               }
-               n := len(e)
-               if n > len(r) {
-                       n = len(r)
-               }
-               for i := 0; i < n; i++ {
-                       if r[i] != e[i] {
-                               t.Errorf("%s:%d:\nexpected\n\t%s\ngot\n\t%s", output, i, e[i], r[i])
+               t.Error(err)
+               return
+       }
+       lineno := 0
+       seq := 0
+       hexByLine := map[string]string{}
+       lines := strings.SplitAfter(string(data), "\n")
+Diff:
+       for _, line := range lines {
+               lineno++
+
+               // The general form of a test input line is:
+               //      // comment
+               //      INST args [// printed form] [// hex encoding]
+               parts := strings.Split(line, "//")
+               printed := strings.TrimSpace(parts[0])
+               if printed == "" || strings.HasSuffix(printed, ":") { // empty or label
+                       continue
+               }
+               seq++
+
+               var hexes string
+               switch len(parts) {
+               default:
+                       t.Errorf("%s:%d: unable to understand comments: %s", input, lineno, line)
+               case 1:
+                       // no comment
+               case 2:
+                       // might be printed form or hex
+                       note := strings.TrimSpace(parts[1])
+                       if isHexes(note) {
+                               hexes = note
+                       } else {
+                               printed = note
+                       }
+               case 3:
+                       // printed form, then hex
+                       printed = strings.TrimSpace(parts[1])
+                       hexes = strings.TrimSpace(parts[2])
+                       if !isHexes(hexes) {
+                               t.Errorf("%s:%d: malformed hex instruction encoding: %s", input, lineno, line)
+                       }
+               }
+
+               if hexes != "" {
+                       hexByLine[fmt.Sprintf("%s:%d", input, lineno)] = hexes
+               }
+
+               // Canonicalize spacing in printed form.
+               // First field is opcode, then tab, then arguments separated by spaces.
+               // Canonicalize spaces after commas first.
+               // Comma to separate argument gets a space; comma within does not.
+               var buf []byte
+               nest := 0
+               for i := 0; i < len(printed); i++ {
+                       c := printed[i]
+                       switch c {
+                       case '{', '[':
+                               nest++
+                       case '}', ']':
+                               nest--
+                       case ',':
+                               buf = append(buf, ',')
+                               if nest == 0 {
+                                       buf = append(buf, ' ')
+                               }
+                               for i+1 < len(printed) && (printed[i+1] == ' ' || printed[i+1] == '\t') {
+                                       i++
+                               }
+                               continue
                        }
+                       buf = append(buf, c)
+               }
+
+               f := strings.Fields(string(buf))
+
+               // Turn relative (PC) into absolute (PC) automatically,
+               // so that most branch instructions don't need comments
+               // giving the absolute form.
+               if len(f) > 0 && strings.HasSuffix(printed, "(PC)") {
+                       last := f[len(f)-1]
+                       n, err := strconv.Atoi(last[:len(last)-len("(PC)")])
+                       if err == nil {
+                               f[len(f)-1] = fmt.Sprintf("%d(PC)", seq+n)
+                       }
+               }
+
+               if len(f) == 1 {
+                       printed = f[0]
+               } else {
+                       printed = f[0] + "\t" + strings.Join(f[1:], " ")
+               }
+
+               want := fmt.Sprintf("%05d (%s:%d)\t%s", seq, input, lineno, printed)
+               for len(output) > 0 && (output[0] < want || output[0] != want && len(output[0]) >= 5 && output[0][:5] == want[:5]) {
+                       if len(output[0]) >= 5 && output[0][:5] == want[:5] {
+                               t.Errorf("mismatched output:\nhave %s\nwant %s", output[0], want)
+                               output = output[1:]
+                               continue Diff
+                       }
+                       t.Errorf("unexpected output: %q", output[0])
+                       output = output[1:]
+               }
+               if len(output) > 0 && output[0] == want {
+                       output = output[1:]
+               } else {
+                       t.Errorf("missing output: %q", want)
+               }
+       }
+       for len(output) > 0 {
+               if output[0] == "" {
+                       // spurious blank caused by Split on "\n"
+                       output = output[1:]
+                       continue
                }
+               t.Errorf("unexpected output: %q", output[0])
+               output = output[1:]
        }
+
+       // Checked printing.
+       // Now check machine code layout.
+
+       top := pList.Firstpc
+       var text *obj.LSym
+       ok = true
+       ctxt.DiagFunc = func(format string, args ...interface{}) {
+               t.Errorf(format, args...)
+               ok = false
+       }
+       obj.Flushplist(ctxt)
+
+       for p := top; p != nil; p = p.Link {
+               if p.As == obj.ATEXT {
+                       text = p.From.Sym
+               }
+               hexes := hexByLine[p.Line()]
+               if hexes == "" {
+                       continue
+               }
+               delete(hexByLine, p.Line())
+               if text == nil {
+                       t.Errorf("%s: instruction outside TEXT", p)
+               }
+               size := int64(len(text.P)) - p.Pc
+               if p.Link != nil {
+                       size = p.Link.Pc - p.Pc
+               } else if p.Isize != 0 {
+                       size = int64(p.Isize)
+               }
+               var code []byte
+               if p.Pc < int64(len(text.P)) {
+                       code = text.P[p.Pc:]
+                       if size < int64(len(code)) {
+                               code = code[:size]
+                       }
+               }
+               codeHex := fmt.Sprintf("%x", code)
+               if codeHex == "" {
+                       codeHex = "empty"
+               }
+               ok := false
+               for _, hex := range strings.Split(hexes, " or ") {
+                       if codeHex == hex {
+                               ok = true
+                               break
+                       }
+               }
+               if !ok {
+                       t.Errorf("%s: have encoding %s, want %s", p, codeHex, hexes)
+               }
+       }
+
+       if len(hexByLine) > 0 {
+               var missing []string
+               for key := range hexByLine {
+                       missing = append(missing, key)
+               }
+               sort.Strings(missing)
+               for _, line := range missing {
+                       t.Errorf("%s: did not find instruction encoding", line)
+               }
+       }
+
 }
 
-func TestPPC64EndToEnd(t *testing.T) {
-       testEndToEnd(t, "ppc64")
+func isHexes(s string) bool {
+       if s == "" {
+               return false
+       }
+       if s == "empty" {
+               return true
+       }
+       for _, f := range strings.Split(s, " or ") {
+               if f == "" || len(f)%2 != 0 || strings.TrimLeft(f, "0123456789abcdef") != "" {
+                       return false
+               }
+       }
+       return true
+}
+
+// It would be nice if the error messages began with
+// the standard file:line: prefix,
+// but that's not where we are today.
+// It might be at the beginning but it might be in the middle of the printed instruction.
+var fileLineRE = regexp.MustCompile(`(?:^|\()(testdata[/\\][0-9a-z]+\.s:[0-9]+)(?:$|\))`)
+
+// Same as in test/run.go
+var (
+       errRE       = regexp.MustCompile(`// ERROR ?(.*)`)
+       errQuotesRE = regexp.MustCompile(`"([^"]*)"`)
+)
+
+func testErrors(t *testing.T, goarch, file string) {
+       lex.InitHist()
+       input := filepath.Join("testdata", file+".s")
+       architecture, ctxt := setArch(goarch)
+       lexer := lex.NewLexer(input, ctxt)
+       parser := NewParser(ctxt, architecture, lexer)
+       pList := obj.Linknewplist(ctxt)
+       var ok bool
+       testOut = new(bytes.Buffer) // The assembler writes test output to this buffer.
+       ctxt.Bso = obj.Binitw(os.Stdout)
+       defer ctxt.Bso.Flush()
+       failed := false
+       var errBuf bytes.Buffer
+       ctxt.DiagFunc = func(format string, args ...interface{}) {
+               failed = true
+               s := fmt.Sprintf(format, args...)
+               if !strings.HasSuffix(s, "\n") {
+                       s += "\n"
+               }
+               errBuf.WriteString(s)
+       }
+       pList.Firstpc, ok = parser.Parse()
+       obj.Flushplist(ctxt)
+       if ok && !failed {
+               t.Errorf("asm: %s had no errors", goarch)
+       }
+
+       errors := map[string]string{}
+       for _, line := range strings.Split(errBuf.String(), "\n") {
+               if line == "" || strings.HasPrefix(line, "\t") {
+                       continue
+               }
+               m := fileLineRE.FindStringSubmatch(line)
+               if m == nil {
+                       t.Errorf("unexpected error: %v", line)
+                       continue
+               }
+               fileline := m[1]
+               if errors[fileline] != "" {
+                       t.Errorf("multiple errors on %s:\n\t%s\n\t%s", fileline, errors[fileline], line)
+                       continue
+               }
+               errors[fileline] = line
+       }
+
+       // Reconstruct expected errors by independently "parsing" the input.
+       data, err := ioutil.ReadFile(input)
+       if err != nil {
+               t.Error(err)
+               return
+       }
+       lineno := 0
+       lines := strings.Split(string(data), "\n")
+       for _, line := range lines {
+               lineno++
+
+               fileline := fmt.Sprintf("%s:%d", input, lineno)
+               if m := errRE.FindStringSubmatch(line); m != nil {
+                       all := m[1]
+                       mm := errQuotesRE.FindAllStringSubmatch(all, -1)
+                       if len(mm) != 1 {
+                               t.Errorf("%s: invalid errorcheck line:\n%s", fileline, line)
+                       } else if err := errors[fileline]; err == "" {
+                               t.Errorf("%s: missing error, want %s", fileline, all)
+                       } else if !strings.Contains(err, mm[0][1]) {
+                               t.Errorf("%s: wrong error for %s:\n%s", fileline, all, err)
+                       }
+               } else {
+                       if errors[fileline] != "" {
+                               t.Errorf("unexpected error on %s: %v", fileline, errors[fileline])
+                       }
+               }
+               delete(errors, fileline)
+       }
+       var extra []string
+       for key := range errors {
+               extra = append(extra, key)
+       }
+       sort.Strings(extra)
+       for _, fileline := range extra {
+               t.Errorf("unexpected error on %s: %v", fileline, errors[fileline])
+       }
+}
+
+func Test386EndToEnd(t *testing.T) {
+       defer os.Setenv("GO386", os.Getenv("GO386"))
+
+       for _, go386 := range []string{"387", "sse"} {
+               os.Setenv("GO386", go386)
+               t.Logf("GO386=%v", os.Getenv("GO386"))
+               testEndToEnd(t, "386", "386")
+       }
 }
 
 func TestARMEndToEnd(t *testing.T) {
-       testEndToEnd(t, "arm")
+       defer os.Setenv("GOARM", os.Getenv("GOARM"))
+
+       for _, goarm := range []string{"5", "6", "7"} {
+               os.Setenv("GOARM", goarm)
+               t.Logf("GOARM=%v", os.Getenv("GOARM"))
+               testEndToEnd(t, "arm", "arm")
+       }
 }
 
 func TestARM64EndToEnd(t *testing.T) {
-       testEndToEnd(t, "arm64")
+       testEndToEnd(t, "arm64", "arm64")
 }
 
 func TestAMD64EndToEnd(t *testing.T) {
-       testEndToEnd(t, "amd64")
+       testEndToEnd(t, "amd64", "amd64")
 }
 
-func Test386EndToEnd(t *testing.T) {
-       testEndToEnd(t, "386")
+func TestAMD64Encoder(t *testing.T) {
+       testEndToEnd(t, "amd64", "amd64enc")
+}
+
+func TestAMD64Errors(t *testing.T) {
+       testErrors(t, "amd64", "amd64error")
 }
 
 func TestMIPS64EndToEnd(t *testing.T) {
-       testEndToEnd(t, "mips64")
+       testEndToEnd(t, "mips64", "mips64")
+}
+
+func TestPPC64EndToEnd(t *testing.T) {
+       testEndToEnd(t, "ppc64", "ppc64")
 }

diff --git a/src/cmd/asm/internal/asm/operand_test.go b/src/cmd/asm/internal/asm/operand_test.go
index ecf52c5620eeaf8cbddc53bd0ba103795a131fbc..bc6a495c98742e61b06372a6bb3655dd59aa8c9a 100644 (file)
--- a/src/cmd/asm/internal/asm/operand_test.go
+++ b/src/cmd/asm/internal/asm/operand_test.go
@@ -127,6 +127,9 @@ var amd64OperandTests = []operandTest{
        {"(SI)(BX*1)", "(SI)(BX*1)"},
        {"(SI)(DX*1)", "(SI)(DX*1)"},
        {"(SP)", "(SP)"},
+       {"(SP)(AX*4)", "(SP)(AX*4)"},
+       {"32(SP)(BX*2)", "32(SP)(BX*2)"},
+       {"32323(SP)(R8*4)", "32323(SP)(R8*4)"},
        {"+3(PC)", "3(PC)"},
        {"-1(DI)(BX*1)", "-1(DI)(BX*1)"},
        {"-3(PC)", "-3(PC)"},

diff --git a/src/cmd/asm/internal/asm/parse.go b/src/cmd/asm/internal/asm/parse.go
index 9a42838be90acbd73c41eadcbcfeebbc470d995e..4258c5ce263f0f58ed9d9035410b24343bdae40e 100644 (file)
--- a/src/cmd/asm/internal/asm/parse.go
+++ b/src/cmd/asm/internal/asm/parse.go
@@ -16,6 +16,7 @@ import (
        "unicode/utf8"
 
        "cmd/asm/internal/arch"
+       "cmd/asm/internal/flags"
        "cmd/asm/internal/lex"
        "cmd/internal/obj"
 )
@@ -78,7 +79,7 @@ func (p *Parser) errorf(format string, args ...interface{}) {
        }
        fmt.Fprintf(p.errorWriter, format, args...)
        p.errorCount++
-       if p.errorCount > 10 {
+       if p.errorCount > 10 && !*flags.AllErrors {
                log.Fatal("too many errors")
        }
 }

diff --git a/src/cmd/asm/internal/asm/testdata/386.out b/src/cmd/asm/internal/asm/testdata/386.out
deleted file mode 100644 (file)
index be43ccb..0000000
--- a/src/cmd/asm/internal/asm/testdata/386.out
+++ /dev/null
@@ -1,49 +0,0 @@
-5 00001 (testdata/386.s:5)     TEXT    foo(SB), 0, $0
-8 00002 (testdata/386.s:8)     SETCC   AX
-9 00003 (testdata/386.s:9)     SETCC   foo+4(SB)
-12 00004 (testdata/386.s:12)   DIVB    AX
-13 00005 (testdata/386.s:13)   DIVB    foo+4(SB)
-14 00006 (testdata/386.s:14)   PUSHL   $foo+4(SB)
-15 00007 (testdata/386.s:15)   POPL    AX
-18 00008 (testdata/386.s:18)   SUBB    $1, AX
-19 00009 (testdata/386.s:19)   SUBB    $1, foo+4(SB)
-20 00010 (testdata/386.s:20)   SUBB    BX, AX
-21 00011 (testdata/386.s:21)   SUBB    BX, foo+4(SB)
-24 00012 (testdata/386.s:24)   CMPB    AX, $1
-25 00013 (testdata/386.s:25)   CMPB    foo+4(SB), $4
-26 00014 (testdata/386.s:26)   CMPB    BX, AX
-27 00015 (testdata/386.s:27)   CMPB    foo+4(SB), BX
-31 00016 (testdata/386.s:31)   JCS
-32 00017 (testdata/386.s:32)   JCS     16(PC)
-35 00018 (testdata/386.s:35)   CALL    AX
-36 00019 (testdata/386.s:36)   JMP     AX
-37 00020 (testdata/386.s:37)   CALL    *foo(SB)
-38 00021 (testdata/386.s:38)   JMP     $4
-39 00022 (testdata/386.s:39)   JMP     16
-40 00023 (testdata/386.s:40)   CALL    foo(SB)
-42 00024 (testdata/386.s:42)   CALL    foo+4(SB)(AX*4)
-43 00025 (testdata/386.s:43)   CALL    4(SP)
-44 00026 (testdata/386.s:44)   CALL    (AX)
-45 00027 (testdata/386.s:45)   CALL    (SP)
-47 00028 (testdata/386.s:47)   CALL    (AX)(AX*4)
-48 00029 (testdata/386.s:48)   CALL    4(SP)
-49 00030 (testdata/386.s:49)   CALL    (AX)
-50 00031 (testdata/386.s:50)   CALL    (SP)
-52 00032 (testdata/386.s:52)   JMP     (AX)(AX*4)
-55 00033 (testdata/386.s:55)   NOP
-56 00034 (testdata/386.s:56)   NOP     AX
-57 00035 (testdata/386.s:57)   NOP     foo+4(SB)
-60 00036 (testdata/386.s:60)   SHLL    $4, BX
-61 00037 (testdata/386.s:61)   SHLL    $4, foo+4(SB)
-62 00038 (testdata/386.s:62)   SHLL    $4, AX, foo+4(SB)
-65 00039 (testdata/386.s:65)   MOVL    AX, BX
-66 00040 (testdata/386.s:66)   MOVL    $4, BX
-69 00041 (testdata/386.s:69)   IMULL   AX
-70 00042 (testdata/386.s:70)   IMULL   $4, CX
-71 00043 (testdata/386.s:71)   IMULL   AX, BX
-74 00044 (testdata/386.s:74)   CMPPD   X0, X1, 4
-75 00045 (testdata/386.s:75)   CMPPD   X0, foo+4(SB), 4
-78 00046 (testdata/386.s:78)   PINSRD  $1, (AX), X0
-79 00047 (testdata/386.s:79)   PINSRD  $2, foo+4(FP), X0
-83 00048 (testdata/386.s:83)   LOOP
-86 00049 (testdata/386.s:86)   RET

diff --git a/src/cmd/asm/internal/asm/testdata/386.s b/src/cmd/asm/internal/asm/testdata/386.s
index 6bee39f3d4162e4f167ebcae05159ee2f6da5a87..4d969d1539c880b15f3c7844bfa86f2be69588e9 100644 (file)
--- a/src/cmd/asm/internal/asm/testdata/386.s
+++ b/src/cmd/asm/internal/asm/testdata/386.s
@@ -2,7 +2,7 @@
 // the old assembler's (8a's) grammar and hand-writing complete
 // instructions for each rule, to guarantee we cover the same space.
 
-TEXT foo(SB), 0, $0
+TEXT foo(SB), 7, $0
 
 // LTYPE1 nonrem       { outcode(int($1), &$2); }
        SETCC   AX
@@ -12,7 +12,7 @@ TEXT foo(SB), 0, $0
        DIVB    AX
        DIVB    foo+4(SB)
        PUSHL   $foo+4(SB)
-       POPL            AX // balance PUSHL
+       POPL            AX
 
 // LTYPE3 rimrem       { outcode(int($1), &$2); }
        SUBB    $1, AX
@@ -28,27 +28,31 @@ TEXT foo(SB), 0, $0
 
 // LTYPER nonrel       { outcode(int($1), &$2); }
 label:
-       JC      label
-       JC      -1(PC)
+       JC      label // JCS
+       JC      -1(PC) // JCS -1(PC)
 
 // LTYPEC spec3        { outcode(int($1), &$2); }
        CALL    AX
-       JMP     *AX
+       JCS     2(PC)
+       JMP     *AX // JMP AX
        CALL    *foo(SB)
+       JCS     2(PC)
        JMP     $4
-       JMP     label
+       JCS     2(PC)
+       JMP     label // JMP 16
        CALL    foo(SB)
-       CALL    (AX*4)
+//     CALL    (AX*4) // TODO: This line is silently dropped on the floor!
        CALL    foo+4(SB)(AX*4)
-       CALL    *4(SP)
-       CALL    *(AX)
-       CALL    *(SP)
-       CALL    *(AX*4)
-       CALL    *(AX)(AX*4)
+       CALL    *4(SP) // CALL 4(SP)
+       CALL    *(AX) // CALL (AX)
+       CALL    *(SP) // CALL (SP)
+//     CALL    *(AX*4) // TODO: This line is silently dropped on the floor!
+       CALL    *(AX)(AX*4) // CALL (AX)(AX*4)
        CALL    4(SP)
        CALL    (AX)
        CALL    (SP)
-       CALL    (AX*4)
+//     CALL    (AX*4) // TODO: This line is silently dropped on the floor!
+       JCS     2(PC)
        JMP     (AX)(AX*4)
 
 // LTYPEN spec4        { outcode(int($1), &$2); }
@@ -59,7 +63,7 @@ label:
 // LTYPES spec5        { outcode(int($1), &$2); }
        SHLL    $4, BX
        SHLL    $4, foo+4(SB)
-       SHLL    $4, foo+4(SB):AX
+       SHLL    $4, foo+4(SB):AX // SHLL $4, AX, foo+4(SB)
 
 // LTYPEM spec6        { outcode(int($1), &$2); }
        MOVL    AX, BX
@@ -72,15 +76,16 @@ label:
 
 // LTYPEXC spec9       { outcode(int($1), &$2); }
        CMPPD   X0, X1, 4
-       CMPPD   X0, foo+4(SB), 4
+       CMPPD   foo+4(SB), X1, 4
 
 // LTYPEX spec10       { outcode(int($1), &$2); }
        PINSRD  $1, (AX), X0
        PINSRD  $2, foo+4(FP), X0
 
 // Was bug: LOOP is a branch instruction.
+       JCS     2(PC)
 loop:
-       LOOP    loop
+       LOOP    loop // LOOP
 
 // LTYPE0 nonnon       { outcode(int($1), &$2); }
        RET

diff --git a/src/cmd/asm/internal/asm/testdata/amd64.out b/src/cmd/asm/internal/asm/testdata/amd64.out
deleted file mode 100644 (file)
index 850a78e..0000000
--- a/src/cmd/asm/internal/asm/testdata/amd64.out
+++ /dev/null
@@ -1,57 +0,0 @@
-9 00001 (testdata/amd64.s:9)   TEXT    foo(SB), 0, $0
-12 00002 (testdata/amd64.s:12) NEGQ    R11
-13 00003 (testdata/amd64.s:13) NEGQ    4(R11)
-14 00004 (testdata/amd64.s:14) NEGQ    foo+4(SB)
-17 00005 (testdata/amd64.s:17) INT     $4
-18 00006 (testdata/amd64.s:18) DIVB    R11
-19 00007 (testdata/amd64.s:19) DIVB    4(R11)
-20 00008 (testdata/amd64.s:20) DIVB    foo+4(SB)
-23 00009 (testdata/amd64.s:23) SUBQ    $4, DI
-24 00010 (testdata/amd64.s:24) SUBQ    R11, DI
-25 00011 (testdata/amd64.s:25) SUBQ    4(R11), DI
-26 00012 (testdata/amd64.s:26) SUBQ    foo+4(SB), DI
-27 00013 (testdata/amd64.s:27) SUBQ    $4, 8(R12)
-28 00014 (testdata/amd64.s:28) SUBQ    R11, 8(R12)
-29 00015 (testdata/amd64.s:29) SUBQ    R11, foo+4(SB)
-32 00016 (testdata/amd64.s:32) CMPB    CX, $4
-36 00017 (testdata/amd64.s:36) JCS     13(PC)
-37 00018 (testdata/amd64.s:37) JCS     17
-40 00019 (testdata/amd64.s:40) JMP     15(PC)
-41 00020 (testdata/amd64.s:41) JMP     17
-42 00021 (testdata/amd64.s:42) JMP     foo+4(SB)
-43 00022 (testdata/amd64.s:43) JMP     bar<>+4(SB)
-44 00023 (testdata/amd64.s:44) JMP     bar<>+4(SB)(R11*4)
-45 00024 (testdata/amd64.s:45) JMP     4(SP)
-46 00025 (testdata/amd64.s:46) JMP     (R12)
-48 00026 (testdata/amd64.s:48) JMP     (R12)(R13*4)
-49 00027 (testdata/amd64.s:49) JMP     (AX)
-50 00028 (testdata/amd64.s:50) JMP     (SP)
-52 00029 (testdata/amd64.s:52) JMP     (AX)(AX*4)
-53 00030 (testdata/amd64.s:53) JMP     4(SP)
-54 00031 (testdata/amd64.s:54) JMP     (R12)
-56 00032 (testdata/amd64.s:56) JMP     (R12)(R13*4)
-57 00033 (testdata/amd64.s:57) JMP     (AX)
-58 00034 (testdata/amd64.s:58) JMP     (SP)
-60 00035 (testdata/amd64.s:60) JMP     (AX)(AX*4)
-61 00036 (testdata/amd64.s:61) JMP     R13
-64 00037 (testdata/amd64.s:64) NOP
-65 00038 (testdata/amd64.s:65) NOP     AX
-66 00039 (testdata/amd64.s:66) NOP     foo+4(SB)
-69 00040 (testdata/amd64.s:69) SHLL    R11, R12
-70 00041 (testdata/amd64.s:70) SHLL    R11, foo+4(SB)
-71 00042 (testdata/amd64.s:71) SHLL    R11, AX, R11
-74 00043 (testdata/amd64.s:74) MOVL    AX, R11
-75 00044 (testdata/amd64.s:75) MOVL    $4, R11
-76 00045 (testdata/amd64.s:76) MOVL    AX, CS, AX
-79 00046 (testdata/amd64.s:79) IMULB   $4
-80 00047 (testdata/amd64.s:80) IMULB   R11
-81 00048 (testdata/amd64.s:81) IMULB   $4, R11
-82 00049 (testdata/amd64.s:82) IMULB   R11, R12
-83 00050 (testdata/amd64.s:83) IMULB   R11, foo+4(SB)
-86 00051 (testdata/amd64.s:86) CMPPD   R11, R12, 4
-87 00052 (testdata/amd64.s:87) CMPPD   R11, foo+4(SB), 4
-90 00053 (testdata/amd64.s:90) PINSRW  $4, R11, AX
-91 00054 (testdata/amd64.s:91) PINSRW  $4, foo+4(SB), AX
-94 00055 (testdata/amd64.s:94) RETFL   $4
-98 00056 (testdata/amd64.s:98) LOOP
-101 00057 (testdata/amd64.s:101)       RET

diff --git a/src/cmd/asm/internal/asm/testdata/amd64.s b/src/cmd/asm/internal/asm/testdata/amd64.s
index 1b32ac459544f2e6173deb0a7a27d6025f01daa6..1411165bf630f1f25c5d1c8d3fba9c46c9aab046 100644 (file)
--- a/src/cmd/asm/internal/asm/testdata/amd64.s
+++ b/src/cmd/asm/internal/asm/testdata/amd64.s
@@ -6,7 +6,7 @@
 // the old assembler's (6a's) grammar and hand-writing complete
 // instructions for each rule, to guarantee we cover the same space.
 
-TEXT   foo(SB), 0, $0
+TEXT   foo(SB), 7, $0
 
 // LTYPE1 nonrem       { outcode($1, &$2); }
        NEGQ    R11
@@ -33,31 +33,53 @@ TEXT        foo(SB), 0, $0
 
 // LTYPER nonrel       { outcode($1, &$2); }
 label:
-       JB      -4(PC)
-       JB      label
+       JB      -4(PC) // JCS -4(PC)
+       JB      label // JCS 17
 
 // LTYPEC spec3        { outcode($1, &$2); }
+       JCS     2(PC)
        JMP     -4(PC)
-       JMP     label
+       JCS     2(PC)
+       JMP     label // JMP 17
+       JCS     2(PC)
        JMP     foo+4(SB)
+       JCS     2(PC)
        JMP     bar<>+4(SB)
+       JCS     2(PC)
        JMP     bar<>+4(SB)(R11*4)
-       JMP     *4(SP)
-       JMP     *(R12)
-       JMP     *(R12*4)
-       JMP     *(R12)(R13*4)
-       JMP     *(AX)
-       JMP     *(SP)
-       JMP     *(AX*4)
-       JMP     *(AX)(AX*4)
+       JCS     2(PC)
+       JMP     *4(SP) // JMP 4(SP)
+       JCS     2(PC)
+       JMP     *(R12) // JMP (R12)
+       JCS     2(PC)
+//     JMP     *(R12*4) // TODO: This line is silently dropped on the floor!
+       JCS     2(PC)
+       JMP     *(R12)(R13*4) // JMP (R12)(R13*4)
+       JCS     2(PC)
+       JMP     *(AX) // JMP (AX)
+       JCS     2(PC)
+       JMP     *(SP) // JMP (SP)
+       JCS     2(PC)
+//     JMP     *(AX*4) // TODO: This line is silently dropped on the floor!
+       JCS     2(PC)
+       JMP     *(AX)(AX*4) // JMP (AX)(AX*4)
+       JCS     2(PC)
        JMP     4(SP)
+       JCS     2(PC)
        JMP     (R12)
-       JMP     (R12*4)
+       JCS     2(PC)
+//     JMP     (R12*4) // TODO: This line is silently dropped on the floor!
+       JCS     2(PC)
        JMP     (R12)(R13*4)
+       JCS     2(PC)
        JMP     (AX)
+       JCS     2(PC)
        JMP     (SP)
-       JMP     (AX*4)
+       JCS     2(PC)
+//     JMP     (AX*4) // TODO: This line is silently dropped on the floor!
+       JCS     2(PC)
        JMP     (AX)(AX*4)
+       JCS     2(PC)
        JMP     R13
 
 // LTYPEN spec4        { outcode($1, &$2); }
@@ -66,36 +88,58 @@ label:
        NOP     foo+4(SB)
 
 // LTYPES spec5        { outcode($1, &$2); }
-       SHLL    R11, R12
-       SHLL    R11, foo+4(SB)
-       SHLL    R11, R11:AX // Old syntax, still accepted.
+       SHLL    CX, R12
+       SHLL    CX, foo+4(SB)
+       // Old syntax, still accepted:
+       SHLL    CX, R11:AX // SHLL CX, AX, R11
 
 // LTYPEM spec6        { outcode($1, &$2); }
        MOVL    AX, R11
        MOVL    $4, R11
-       MOVL    AX, AX:CS
+//     MOVL    AX, 0(AX):DS // no longer works - did it ever?
 
 // LTYPEI spec7        { outcode($1, &$2); }
-       IMULB   $4
-       IMULB   R11
-       IMULB   $4, R11
-       IMULB   R11, R12
-       IMULB   R11, foo+4(SB)
+       IMULB   DX
+       IMULW   DX, BX
+       IMULL   R11, R12
+       IMULQ   foo+4(SB), R11
 
 // LTYPEXC spec8       { outcode($1, &$2); }
-       CMPPD   R11, R12, 4
-       CMPPD   R11, foo+4(SB), 4
+       CMPPD   X1, X2, 4
+       CMPPD   foo+4(SB), X2, 4
 
 // LTYPEX spec9        { outcode($1, &$2); }
-       PINSRW  $4, R11, AX
-       PINSRW  $4, foo+4(SB), AX
+       PINSRW  $4, AX, X2
+       PINSRW  $4, foo+4(SB), X2
 
 // LTYPERT spec10      { outcode($1, &$2); }
+       JCS     2(PC)
        RETFL   $4
 
 // Was bug: LOOP is a branch instruction.
+       JCS     2(PC)
 loop:
-       LOOP    loop
+       LOOP    loop // LOOP
+
+       // Intel pseudonyms for our own renamings.
+       PADDD   M2, M1 // PADDL M2, M1
+       MOVDQ2Q X1, M1 // MOVQ X1, M1
+       MOVNTDQ X1, (AX)        // MOVNTO X1, (AX)
+       MOVOA   (AX), X1        // MOVO (AX), X1
+
+// Tests for SP indexed addresses.
+       MOVQ    foo(SP)(AX*1), BX               // 488b1c04
+       MOVQ    foo+32(SP)(CX*2), DX            // 488b544c20
+       MOVQ    foo+32323(SP)(R8*4), R9         // 4e8b8c84437e0000
+       MOVL    foo(SP)(SI*8), DI               // 8b3cf4
+       MOVL    foo+32(SP)(R10*1), R11          // 468b5c1420
+       MOVL    foo+32323(SP)(R12*2), R13       // 468bac64437e0000
+       MOVW    foo(SP)(AX*4), R8               // 66448b0484
+       MOVW    foo+32(SP)(R9*8), CX            // 66428b4ccc20
+       MOVW    foo+32323(SP)(AX*1), DX         // 668b9404437e0000
+       MOVB    foo(SP)(AX*2), AL               // 8a0444
+       MOVB    foo+32(SP)(CX*4), AH            // 8a648c20
+       MOVB    foo+32323(SP)(CX*8), R9         // 448a8ccc437e0000
 
 // LTYPE0 nonnon       { outcode($1, &$2); }
-       RET
+       RET // c3

diff --git a/src/cmd/asm/internal/asm/testdata/amd64enc.s b/src/cmd/asm/internal/asm/testdata/amd64enc.s
new file mode 100644 (file)
index 0000000..63fdcac
--- /dev/null
+++ b/src/cmd/asm/internal/asm/testdata/amd64enc.s
@@ -0,0 +1,10682 @@
+// generated by x86test -amd64
+// DO NOT EDIT
+
+TEXT asmtest(SB),7,$0
+       ADCB $7, AL                             // 1407
+       ADCW $61731, AX                         // 661523f1
+       ADCL $4045620583, AX                    // 15674523f1
+       ADCQ $-249346713, AX                    // 4815674523f1
+       ADCW $61731, (BX)                       // 66811323f1
+       ADCW $61731, (R11)                      // 6641811323f1
+       ADCW $61731, DX                         // 6681d223f1
+       ADCW $61731, R11                        // 664181d323f1
+       ADCW $7, (BX)                           // 66831307
+       ADCW $7, (R11)                          // 6641831307
+       ADCW $7, DX                             // 6683d207
+       ADCW $7, R11                            // 664183d307
+       ADCW DX, (BX)                           // 661113
+       ADCW R11, (BX)                          // 6644111b
+       ADCW DX, (R11)                          // 66411113
+       ADCW R11, (R11)                         // 6645111b
+       ADCW DX, DX                             // 6611d2 or 6613d2
+       ADCW R11, DX                            // 664411da or 664113d3
+       ADCW DX, R11                            // 664111d3 or 664413da
+       ADCW R11, R11                           // 664511db or 664513db
+       ADCL $4045620583, (BX)                  // 8113674523f1
+       ADCL $4045620583, (R11)                 // 418113674523f1
+       ADCL $4045620583, DX                    // 81d2674523f1
+       ADCL $4045620583, R11                   // 4181d3674523f1
+       ADCL $7, (BX)                           // 831307
+       ADCL $7, (R11)                          // 41831307
+       ADCL $7, DX                             // 83d207
+       ADCL $7, R11                            // 4183d307
+       ADCL DX, (BX)                           // 1113
+       ADCL R11, (BX)                          // 44111b
+       ADCL DX, (R11)                          // 411113
+       ADCL R11, (R11)                         // 45111b
+       ADCL DX, DX                             // 11d2 or 13d2
+       ADCL R11, DX                            // 4411da or 4113d3
+       ADCL DX, R11                            // 4111d3 or 4413da
+       ADCL R11, R11                           // 4511db or 4513db
+       ADCQ $-249346713, (BX)                  // 488113674523f1
+       ADCQ $-249346713, (R11)                 // 498113674523f1
+       ADCQ $-249346713, DX                    // 4881d2674523f1
+       ADCQ $-249346713, R11                   // 4981d3674523f1
+       ADCQ $7, (BX)                           // 48831307
+       ADCQ $7, (R11)                          // 49831307
+       ADCQ $7, DX                             // 4883d207
+       ADCQ $7, R11                            // 4983d307
+       ADCQ DX, (BX)                           // 481113
+       ADCQ R11, (BX)                          // 4c111b
+       ADCQ DX, (R11)                          // 491113
+       ADCQ R11, (R11)                         // 4d111b
+       ADCQ DX, DX                             // 4811d2 or 4813d2
+       ADCQ R11, DX                            // 4c11da or 4913d3
+       ADCQ DX, R11                            // 4911d3 or 4c13da
+       ADCQ R11, R11                           // 4d11db or 4d13db
+       ADCB $7, (BX)                           // 801307
+       ADCB $7, (R11)                          // 41801307
+       ADCB $7, DL                             // 80d207
+       ADCB $7, R11                            // 4180d307
+       ADCB DL, (BX)                           // 1013
+       ADCB R11, (BX)                          // 44101b
+       ADCB DL, (R11)                          // 411013
+       ADCB R11, (R11)                         // 45101b
+       ADCB DL, DL                             // 10d2 or 12d2
+       ADCB R11, DL                            // 4410da or 4112d3
+       ADCB DL, R11                            // 4110d3 or 4412da
+       ADCB R11, R11                           // 4510db or 4512db
+       ADCW (BX), DX                           // 661313
+       ADCW (R11), DX                          // 66411313
+       ADCW (BX), R11                          // 6644131b
+       ADCW (R11), R11                         // 6645131b
+       ADCL (BX), DX                           // 1313
+       ADCL (R11), DX                          // 411313
+       ADCL (BX), R11                          // 44131b
+       ADCL (R11), R11                         // 45131b
+       ADCQ (BX), DX                           // 481313
+       ADCQ (R11), DX                          // 491313
+       ADCQ (BX), R11                          // 4c131b
+       ADCQ (R11), R11                         // 4d131b
+       //TODO: ADCB (BX), DL                   // 1213
+       //TODO: ADCB (R11), DL                  // 411213
+       //TODO: ADCB (BX), R11                  // 44121b
+       //TODO: ADCB (R11), R11                 // 45121b
+       //TODO: ADCXL (BX), DX                  // 660f38f613
+       //TODO: ADCXL (R11), DX                 // 66410f38f613
+       //TODO: ADCXL DX, DX                    // 660f38f6d2
+       //TODO: ADCXL R11, DX                   // 66410f38f6d3
+       //TODO: ADCXL (BX), R11                 // 66440f38f61b
+       //TODO: ADCXL (R11), R11                // 66450f38f61b
+       //TODO: ADCXL DX, R11                   // 66440f38f6da
+       //TODO: ADCXL R11, R11                  // 66450f38f6db
+       //TODO: ADCXQ (BX), DX                  // 66480f38f613
+       //TODO: ADCXQ (R11), DX                 // 66490f38f613
+       //TODO: ADCXQ DX, DX                    // 66480f38f6d2
+       //TODO: ADCXQ R11, DX                   // 66490f38f6d3
+       //TODO: ADCXQ (BX), R11                 // 664c0f38f61b
+       //TODO: ADCXQ (R11), R11                // 664d0f38f61b
+       //TODO: ADCXQ DX, R11                   // 664c0f38f6da
+       //TODO: ADCXQ R11, R11                  // 664d0f38f6db
+       ADDB $7, AL                             // 0407
+       ADDW $61731, AX                         // 660523f1
+       ADDL $4045620583, AX                    // 05674523f1
+       ADDQ $-249346713, AX                    // 4805674523f1
+       ADDW $61731, (BX)                       // 66810323f1
+       ADDW $61731, (R11)                      // 6641810323f1
+       ADDW $61731, DX                         // 6681c223f1
+       ADDW $61731, R11                        // 664181c323f1
+       ADDW $7, (BX)                           // 66830307
+       ADDW $7, (R11)                          // 6641830307
+       ADDW $7, DX                             // 6683c207
+       ADDW $7, R11                            // 664183c307
+       ADDW DX, (BX)                           // 660113
+       ADDW R11, (BX)                          // 6644011b
+       ADDW DX, (R11)                          // 66410113
+       ADDW R11, (R11)                         // 6645011b
+       ADDW DX, DX                             // 6601d2 or 6603d2
+       ADDW R11, DX                            // 664401da or 664103d3
+       ADDW DX, R11                            // 664101d3 or 664403da
+       ADDW R11, R11                           // 664501db or 664503db
+       ADDL $4045620583, (BX)                  // 8103674523f1
+       ADDL $4045620583, (R11)                 // 418103674523f1
+       ADDL $4045620583, DX                    // 81c2674523f1
+       ADDL $4045620583, R11                   // 4181c3674523f1
+       ADDL $7, (BX)                           // 830307
+       ADDL $7, (R11)                          // 41830307
+       ADDL $7, DX                             // 83c207
+       ADDL $7, R11                            // 4183c307
+       ADDL DX, (BX)                           // 0113
+       ADDL R11, (BX)                          // 44011b
+       ADDL DX, (R11)                          // 410113
+       ADDL R11, (R11)                         // 45011b
+       ADDL DX, DX                             // 01d2 or 03d2
+       ADDL R11, DX                            // 4401da or 4103d3
+       ADDL DX, R11                            // 4101d3 or 4403da
+       ADDL R11, R11                           // 4501db or 4503db
+       ADDQ $-249346713, (BX)                  // 488103674523f1
+       ADDQ $-249346713, (R11)                 // 498103674523f1
+       ADDQ $-249346713, DX                    // 4881c2674523f1
+       ADDQ $-249346713, R11                   // 4981c3674523f1
+       ADDQ $7, (BX)                           // 48830307
+       ADDQ $7, (R11)                          // 49830307
+       ADDQ $7, DX                             // 4883c207
+       ADDQ $7, R11                            // 4983c307
+       ADDQ DX, (BX)                           // 480113
+       ADDQ R11, (BX)                          // 4c011b
+       ADDQ DX, (R11)                          // 490113
+       ADDQ R11, (R11)                         // 4d011b
+       ADDQ DX, DX                             // 4801d2 or 4803d2
+       ADDQ R11, DX                            // 4c01da or 4903d3
+       ADDQ DX, R11                            // 4901d3 or 4c03da
+       ADDQ R11, R11                           // 4d01db or 4d03db
+       ADDB $7, (BX)                           // 800307
+       ADDB $7, (R11)                          // 41800307
+       ADDB $7, DL                             // 80c207
+       ADDB $7, R11                            // 4180c307
+       ADDB DL, (BX)                           // 0013
+       ADDB R11, (BX)                          // 44001b
+       ADDB DL, (R11)                          // 410013
+       ADDB R11, (R11)                         // 45001b
+       ADDB DL, DL                             // 00d2 or 02d2
+       ADDB R11, DL                            // 4400da or 4102d3
+       ADDB DL, R11                            // 4100d3 or 4402da
+       ADDB R11, R11                           // 4500db or 4502db
+       ADDW (BX), DX                           // 660313
+       ADDW (R11), DX                          // 66410313
+       ADDW (BX), R11                          // 6644031b
+       ADDW (R11), R11                         // 6645031b
+       ADDL (BX), DX                           // 0313
+       ADDL (R11), DX                          // 410313
+       ADDL (BX), R11                          // 44031b
+       ADDL (R11), R11                         // 45031b
+       ADDQ (BX), DX                           // 480313
+       ADDQ (R11), DX                          // 490313
+       ADDQ (BX), R11                          // 4c031b
+       ADDQ (R11), R11                         // 4d031b
+       ADDB (BX), DL                           // 0213
+       ADDB (R11), DL                          // 410213
+       ADDB (BX), R11                          // 44021b
+       ADDB (R11), R11                         // 45021b
+       ADDPD (BX), X2                          // 660f5813
+       ADDPD (R11), X2                         // 66410f5813
+       ADDPD X2, X2                            // 660f58d2
+       ADDPD X11, X2                           // 66410f58d3
+       ADDPD (BX), X11                         // 66440f581b
+       ADDPD (R11), X11                        // 66450f581b
+       ADDPD X2, X11                           // 66440f58da
+       ADDPD X11, X11                          // 66450f58db
+       ADDPS (BX), X2                          // 0f5813
+       ADDPS (R11), X2                         // 410f5813
+       ADDPS X2, X2                            // 0f58d2
+       ADDPS X11, X2                           // 410f58d3
+       ADDPS (BX), X11                         // 440f581b
+       ADDPS (R11), X11                        // 450f581b
+       ADDPS X2, X11                           // 440f58da
+       ADDPS X11, X11                          // 450f58db
+       ADDSD (BX), X2                          // f20f5813
+       ADDSD (R11), X2                         // f2410f5813
+       ADDSD X2, X2                            // f20f58d2
+       ADDSD X11, X2                           // f2410f58d3
+       ADDSD (BX), X11                         // f2440f581b
+       ADDSD (R11), X11                        // f2450f581b
+       ADDSD X2, X11                           // f2440f58da
+       ADDSD X11, X11                          // f2450f58db
+       ADDSS (BX), X2                          // f30f5813
+       ADDSS (R11), X2                         // f3410f5813
+       ADDSS X2, X2                            // f30f58d2
+       ADDSS X11, X2                           // f3410f58d3
+       ADDSS (BX), X11                         // f3440f581b
+       ADDSS (R11), X11                        // f3450f581b
+       ADDSS X2, X11                           // f3440f58da
+       ADDSS X11, X11                          // f3450f58db
+       //TODO: ADDSUBPD (BX), X2               // 660fd013
+       //TODO: ADDSUBPD (R11), X2              // 66410fd013
+       //TODO: ADDSUBPD X2, X2                 // 660fd0d2
+       //TODO: ADDSUBPD X11, X2                // 66410fd0d3
+       //TODO: ADDSUBPD (BX), X11              // 66440fd01b
+       //TODO: ADDSUBPD (R11), X11             // 66450fd01b
+       //TODO: ADDSUBPD X2, X11                // 66440fd0da
+       //TODO: ADDSUBPD X11, X11               // 66450fd0db
+       //TODO: ADDSUBPS (BX), X2               // f20fd013
+       //TODO: ADDSUBPS (R11), X2              // f2410fd013
+       //TODO: ADDSUBPS X2, X2                 // f20fd0d2
+       //TODO: ADDSUBPS X11, X2                // f2410fd0d3
+       //TODO: ADDSUBPS (BX), X11              // f2440fd01b
+       //TODO: ADDSUBPS (R11), X11             // f2450fd01b
+       //TODO: ADDSUBPS X2, X11                // f2440fd0da
+       //TODO: ADDSUBPS X11, X11               // f2450fd0db
+       //TODO: ADOXL (BX), DX                  // f30f38f613
+       //TODO: ADOXL (R11), DX                 // f3410f38f613
+       //TODO: ADOXL DX, DX                    // f30f38f6d2
+       //TODO: ADOXL R11, DX                   // f3410f38f6d3
+       //TODO: ADOXL (BX), R11                 // f3440f38f61b
+       //TODO: ADOXL (R11), R11                // f3450f38f61b
+       //TODO: ADOXL DX, R11                   // f3440f38f6da
+       //TODO: ADOXL R11, R11                  // f3450f38f6db
+       //TODO: ADOXQ (BX), DX                  // f3480f38f613
+       //TODO: ADOXQ (R11), DX                 // f3490f38f613
+       //TODO: ADOXQ DX, DX                    // f3480f38f6d2
+       //TODO: ADOXQ R11, DX                   // f3490f38f6d3
+       //TODO: ADOXQ (BX), R11                 // f34c0f38f61b
+       //TODO: ADOXQ (R11), R11                // f34d0f38f61b
+       //TODO: ADOXQ DX, R11                   // f34c0f38f6da
+       //TODO: ADOXQ R11, R11                  // f34d0f38f6db
+       AESDEC (BX), X2                         // 660f38de13
+       AESDEC (R11), X2                        // 66410f38de13
+       AESDEC X2, X2                           // 660f38ded2
+       AESDEC X11, X2                          // 66410f38ded3
+       AESDEC (BX), X11                        // 66440f38de1b
+       AESDEC (R11), X11                       // 66450f38de1b
+       AESDEC X2, X11                          // 66440f38deda
+       AESDEC X11, X11                         // 66450f38dedb
+       AESDECLAST (BX), X2                     // 660f38df13
+       AESDECLAST (R11), X2                    // 66410f38df13
+       AESDECLAST X2, X2                       // 660f38dfd2
+       AESDECLAST X11, X2                      // 66410f38dfd3
+       AESDECLAST (BX), X11                    // 66440f38df1b
+       AESDECLAST (R11), X11                   // 66450f38df1b
+       AESDECLAST X2, X11                      // 66440f38dfda
+       AESDECLAST X11, X11                     // 66450f38dfdb
+       AESENC (BX), X2                         // 660f38dc13
+       AESENC (R11), X2                        // 66410f38dc13
+       AESENC X2, X2                           // 660f38dcd2
+       AESENC X11, X2                          // 66410f38dcd3
+       AESENC (BX), X11                        // 66440f38dc1b
+       AESENC (R11), X11                       // 66450f38dc1b
+       AESENC X2, X11                          // 66440f38dcda
+       AESENC X11, X11                         // 66450f38dcdb
+       AESENCLAST (BX), X2                     // 660f38dd13
+       AESENCLAST (R11), X2                    // 66410f38dd13
+       AESENCLAST X2, X2                       // 660f38ddd2
+       AESENCLAST X11, X2                      // 66410f38ddd3
+       AESENCLAST (BX), X11                    // 66440f38dd1b
+       AESENCLAST (R11), X11                   // 66450f38dd1b
+       AESENCLAST X2, X11                      // 66440f38ddda
+       AESENCLAST X11, X11                     // 66450f38dddb
+       AESIMC (BX), X2                         // 660f38db13
+       AESIMC (R11), X2                        // 66410f38db13
+       AESIMC X2, X2                           // 660f38dbd2
+       AESIMC X11, X2                          // 66410f38dbd3
+       AESIMC (BX), X11                        // 66440f38db1b
+       AESIMC (R11), X11                       // 66450f38db1b
+       AESIMC X2, X11                          // 66440f38dbda
+       AESIMC X11, X11                         // 66450f38dbdb
+       AESKEYGENASSIST $7, (BX), X2            // 660f3adf1307
+       AESKEYGENASSIST $7, (R11), X2           // 66410f3adf1307
+       AESKEYGENASSIST $7, X2, X2              // 660f3adfd207
+       AESKEYGENASSIST $7, X11, X2             // 66410f3adfd307
+       AESKEYGENASSIST $7, (BX), X11           // 66440f3adf1b07
+       AESKEYGENASSIST $7, (R11), X11          // 66450f3adf1b07
+       AESKEYGENASSIST $7, X2, X11             // 66440f3adfda07
+       AESKEYGENASSIST $7, X11, X11            // 66450f3adfdb07
+       ANDB $7, AL                             // 2407
+       ANDW $61731, AX                         // 662523f1
+       ANDL $4045620583, AX                    // 25674523f1
+       ANDQ $-249346713, AX                    // 4825674523f1
+       ANDW $61731, (BX)                       // 66812323f1
+       ANDW $61731, (R11)                      // 6641812323f1
+       ANDW $61731, DX                         // 6681e223f1
+       ANDW $61731, R11                        // 664181e323f1
+       ANDW $7, (BX)                           // 66832307
+       ANDW $7, (R11)                          // 6641832307
+       ANDW $7, DX                             // 6683e207
+       ANDW $7, R11                            // 664183e307
+       ANDW DX, (BX)                           // 662113
+       ANDW R11, (BX)                          // 6644211b
+       ANDW DX, (R11)                          // 66412113
+       ANDW R11, (R11)                         // 6645211b
+       ANDW DX, DX                             // 6621d2 or 6623d2
+       ANDW R11, DX                            // 664421da or 664123d3
+       ANDW DX, R11                            // 664121d3 or 664423da
+       ANDW R11, R11                           // 664521db or 664523db
+       ANDL $4045620583, (BX)                  // 8123674523f1
+       ANDL $4045620583, (R11)                 // 418123674523f1
+       ANDL $4045620583, DX                    // 81e2674523f1
+       ANDL $4045620583, R11                   // 4181e3674523f1
+       ANDL $7, (BX)                           // 832307
+       ANDL $7, (R11)                          // 41832307
+       ANDL $7, DX                             // 83e207
+       ANDL $7, R11                            // 4183e307
+       ANDL DX, (BX)                           // 2113
+       ANDL R11, (BX)                          // 44211b
+       ANDL DX, (R11)                          // 412113
+       ANDL R11, (R11)                         // 45211b
+       ANDL DX, DX                             // 21d2 or 23d2
+       ANDL R11, DX                            // 4421da or 4123d3
+       ANDL DX, R11                            // 4121d3 or 4423da
+       ANDL R11, R11                           // 4521db or 4523db
+       ANDQ $-249346713, (BX)                  // 488123674523f1
+       ANDQ $-249346713, (R11)                 // 498123674523f1
+       ANDQ $-249346713, DX                    // 4881e2674523f1
+       ANDQ $-249346713, R11                   // 4981e3674523f1
+       ANDQ $7, (BX)                           // 48832307
+       ANDQ $7, (R11)                          // 49832307
+       ANDQ $7, DX                             // 4883e207
+       ANDQ $7, R11                            // 4983e307
+       ANDQ DX, (BX)                           // 482113
+       ANDQ R11, (BX)                          // 4c211b
+       ANDQ DX, (R11)                          // 492113
+       ANDQ R11, (R11)                         // 4d211b
+       ANDQ DX, DX                             // 4821d2 or 4823d2
+       ANDQ R11, DX                            // 4c21da or 4923d3
+       ANDQ DX, R11                            // 4921d3 or 4c23da
+       ANDQ R11, R11                           // 4d21db or 4d23db
+       ANDB $7, (BX)                           // 802307
+       ANDB $7, (R11)                          // 41802307
+       ANDB $7, DL                             // 80e207
+       ANDB $7, R11                            // 4180e307
+       ANDB DL, (BX)                           // 2013
+       ANDB R11, (BX)                          // 44201b
+       ANDB DL, (R11)                          // 412013
+       ANDB R11, (R11)                         // 45201b
+       ANDB DL, DL                             // 20d2 or 22d2
+       ANDB R11, DL                            // 4420da or 4122d3
+       ANDB DL, R11                            // 4120d3 or 4422da
+       ANDB R11, R11                           // 4520db or 4522db
+       ANDW (BX), DX                           // 662313
+       ANDW (R11), DX                          // 66412313
+       ANDW (BX), R11                          // 6644231b
+       ANDW (R11), R11                         // 6645231b
+       ANDL (BX), DX                           // 2313
+       ANDL (R11), DX                          // 412313
+       ANDL (BX), R11                          // 44231b
+       ANDL (R11), R11                         // 45231b
+       ANDQ (BX), DX                           // 482313
+       ANDQ (R11), DX                          // 492313
+       ANDQ (BX), R11                          // 4c231b
+       ANDQ (R11), R11                         // 4d231b
+       ANDB (BX), DL                           // 2213
+       ANDB (R11), DL                          // 412213
+       ANDB (BX), R11                          // 44221b
+       ANDB (R11), R11                         // 45221b
+       ANDNL (BX), R9, DX                      // c4e230f213
+       ANDNL (R11), R9, DX                     // c4c230f213
+       ANDNL DX, R9, DX                        // c4e230f2d2
+       ANDNL R11, R9, DX                       // c4c230f2d3
+       ANDNL (BX), R9, R11                     // c46230f21b
+       ANDNL (R11), R9, R11                    // c44230f21b
+       ANDNL DX, R9, R11                       // c46230f2da
+       ANDNL R11, R9, R11                      // c44230f2db
+       ANDNQ (BX), R14, DX                     // c4e288f213
+       ANDNQ (R11), R14, DX                    // c4c288f213
+       ANDNQ DX, R14, DX                       // c4e288f2d2
+       ANDNQ R11, R14, DX                      // c4c288f2d3
+       ANDNQ (BX), R14, R11                    // c46288f21b
+       ANDNQ (R11), R14, R11                   // c44288f21b
+       ANDNQ DX, R14, R11                      // c46288f2da
+       ANDNQ R11, R14, R11                     // c44288f2db
+       ANDNPD (BX), X2                         // 660f5513
+       ANDNPD (R11), X2                        // 66410f5513
+       ANDNPD X2, X2                           // 660f55d2
+       ANDNPD X11, X2                          // 66410f55d3
+       ANDNPD (BX), X11                        // 66440f551b
+       ANDNPD (R11), X11                       // 66450f551b
+       ANDNPD X2, X11                          // 66440f55da
+       ANDNPD X11, X11                         // 66450f55db
+       ANDNPS (BX), X2                         // 0f5513
+       ANDNPS (R11), X2                        // 410f5513
+       ANDNPS X2, X2                           // 0f55d2
+       ANDNPS X11, X2                          // 410f55d3
+       ANDNPS (BX), X11                        // 440f551b
+       ANDNPS (R11), X11                       // 450f551b
+       ANDNPS X2, X11                          // 440f55da
+       ANDNPS X11, X11                         // 450f55db
+       ANDPD (BX), X2                          // 660f5413
+       ANDPD (R11), X2                         // 66410f5413
+       ANDPD X2, X2                            // 660f54d2
+       ANDPD X11, X2                           // 66410f54d3
+       ANDPD (BX), X11                         // 66440f541b
+       ANDPD (R11), X11                        // 66450f541b
+       ANDPD X2, X11                           // 66440f54da
+       ANDPD X11, X11                          // 66450f54db
+       //TODO: ANDPS (BX), X2                  // 0f5413
+       //TODO: ANDPS (R11), X2                 // 410f5413
+       //TODO: ANDPS X2, X2                    // 0f54d2
+       //TODO: ANDPS X11, X2                   // 410f54d3
+       //TODO: ANDPS (BX), X11                 // 440f541b
+       //TODO: ANDPS (R11), X11                // 450f541b
+       //TODO: ANDPS X2, X11                   // 440f54da
+       //TODO: ANDPS X11, X11                  // 450f54db
+       BEXTRL R9, (BX), DX                     // c4e230f713
+       BEXTRL R9, (R11), DX                    // c4c230f713
+       BEXTRL R9, DX, DX                       // c4e230f7d2
+       BEXTRL R9, R11, DX                      // c4c230f7d3
+       BEXTRL R9, (BX), R11                    // c46230f71b
+       BEXTRL R9, (R11), R11                   // c44230f71b
+       BEXTRL R9, DX, R11                      // c46230f7da
+       BEXTRL R9, R11, R11                     // c44230f7db
+       BEXTRQ R14, (BX), DX                    // c4e288f713
+       BEXTRQ R14, (R11), DX                   // c4c288f713
+       BEXTRQ R14, DX, DX                      // c4e288f7d2
+       BEXTRQ R14, R11, DX                     // c4c288f7d3
+       BEXTRQ R14, (BX), R11                   // c46288f71b
+       BEXTRQ R14, (R11), R11                  // c44288f71b
+       BEXTRQ R14, DX, R11                     // c46288f7da
+       BEXTRQ R14, R11, R11                    // c44288f7db
+       //TODO: BLENDPD $7, (BX), X2            // 660f3a0d1307
+       //TODO: BLENDPD $7, (R11), X2           // 66410f3a0d1307
+       //TODO: BLENDPD $7, X2, X2              // 660f3a0dd207
+       //TODO: BLENDPD $7, X11, X2             // 66410f3a0dd307
+       //TODO: BLENDPD $7, (BX), X11           // 66440f3a0d1b07
+       //TODO: BLENDPD $7, (R11), X11          // 66450f3a0d1b07
+       //TODO: BLENDPD $7, X2, X11             // 66440f3a0dda07
+       //TODO: BLENDPD $7, X11, X11            // 66450f3a0ddb07
+       //TODO: BLENDPS $7, (BX), X2            // 660f3a0c1307
+       //TODO: BLENDPS $7, (R11), X2           // 66410f3a0c1307
+       //TODO: BLENDPS $7, X2, X2              // 660f3a0cd207
+       //TODO: BLENDPS $7, X11, X2             // 66410f3a0cd307
+       //TODO: BLENDPS $7, (BX), X11           // 66440f3a0c1b07
+       //TODO: BLENDPS $7, (R11), X11          // 66450f3a0c1b07
+       //TODO: BLENDPS $7, X2, X11             // 66440f3a0cda07
+       //TODO: BLENDPS $7, X11, X11            // 66450f3a0cdb07
+       //TODO: BLENDVPD XMM0, (BX), X2         // 660f381513
+       //TODO: BLENDVPD XMM0, (R11), X2        // 66410f381513
+       //TODO: BLENDVPD XMM0, X2, X2           // 660f3815d2
+       //TODO: BLENDVPD XMM0, X11, X2          // 66410f3815d3
+       //TODO: BLENDVPD XMM0, (BX), X11        // 66440f38151b
+       //TODO: BLENDVPD XMM0, (R11), X11       // 66450f38151b
+       //TODO: BLENDVPD XMM0, X2, X11          // 66440f3815da
+       //TODO: BLENDVPD XMM0, X11, X11         // 66450f3815db
+       //TODO: BLENDVPS XMM0, (BX), X2         // 660f381413
+       //TODO: BLENDVPS XMM0, (R11), X2        // 66410f381413
+       //TODO: BLENDVPS XMM0, X2, X2           // 660f3814d2
+       //TODO: BLENDVPS XMM0, X11, X2          // 66410f3814d3
+       //TODO: BLENDVPS XMM0, (BX), X11        // 66440f38141b
+       //TODO: BLENDVPS XMM0, (R11), X11       // 66450f38141b
+       //TODO: BLENDVPS XMM0, X2, X11          // 66440f3814da
+       //TODO: BLENDVPS XMM0, X11, X11         // 66450f3814db
+       //TODO: BLSIL (BX), R9                  // c4e230f31b
+       //TODO: BLSIL (R11), R9                 // c4c230f31b
+       //TODO: BLSIL DX, R9                    // c4e230f3da
+       //TODO: BLSIL R11, R9                   // c4c230f3db
+       //TODO: BLSIQ (BX), R14                 // c4e288f31b
+       //TODO: BLSIQ (R11), R14                // c4c288f31b
+       //TODO: BLSIQ DX, R14                   // c4e288f3da
+       //TODO: BLSIQ R11, R14                  // c4c288f3db
+       //TODO: BLSMSKL (BX), R9                // c4e230f313
+       //TODO: BLSMSKL (R11), R9               // c4c230f313
+       //TODO: BLSMSKL DX, R9                  // c4e230f3d2
+       //TODO: BLSMSKL R11, R9                 // c4c230f3d3
+       //TODO: BLSMSKQ (BX), R14               // c4e288f313
+       //TODO: BLSMSKQ (R11), R14              // c4c288f313
+       //TODO: BLSMSKQ DX, R14                 // c4e288f3d2
+       //TODO: BLSMSKQ R11, R14                // c4c288f3d3
+       //TODO: BLSRL (BX), R9                  // c4e230f30b
+       //TODO: BLSRL (R11), R9                 // c4c230f30b
+       //TODO: BLSRL DX, R9                    // c4e230f3ca
+       //TODO: BLSRL R11, R9                   // c4c230f3cb
+       //TODO: BLSRQ (BX), R14                 // c4e288f30b
+       //TODO: BLSRQ (R11), R14                // c4c288f30b
+       //TODO: BLSRQ DX, R14                   // c4e288f3ca
+       //TODO: BLSRQ R11, R14                  // c4c288f3cb
+       //TODO: BNDCL (BX), BND2                // f30f1a13
+       //TODO: BNDCL (R11), BND2               // f3410f1a13
+       //TODO: BNDCL DX, BND2                  // f30f1ad2
+       //TODO: BNDCL R11, BND2                 // f3410f1ad3
+       //TODO: BNDCL (BX), BND3                // f30f1a1b
+       //TODO: BNDCL (R11), BND3               // f3410f1a1b
+       //TODO: BNDCL DX, BND3                  // f30f1ada
+       //TODO: BNDCL R11, BND3                 // f3410f1adb
+       //TODO: BNDCN (BX), BND2                // f20f1b13
+       //TODO: BNDCN (R11), BND2               // f2410f1b13
+       //TODO: BNDCN DX, BND2                  // f20f1bd2
+       //TODO: BNDCN R11, BND2                 // f2410f1bd3
+       //TODO: BNDCN (BX), BND3                // f20f1b1b
+       //TODO: BNDCN (R11), BND3               // f2410f1b1b
+       //TODO: BNDCN DX, BND3                  // f20f1bda
+       //TODO: BNDCN R11, BND3                 // f2410f1bdb
+       //TODO: BNDCU (BX), BND2                // f20f1a13
+       //TODO: BNDCU (R11), BND2               // f2410f1a13
+       //TODO: BNDCU DX, BND2                  // f20f1ad2
+       //TODO: BNDCU R11, BND2                 // f2410f1ad3
+       //TODO: BNDCU (BX), BND3                // f20f1a1b
+       //TODO: BNDCU (R11), BND3               // f2410f1a1b
+       //TODO: BNDCU DX, BND3                  // f20f1ada
+       //TODO: BNDCU R11, BND3                 // f2410f1adb
+       //TODO: BNDLDX (BX), BND2               // 0f1a13
+       //TODO: BNDLDX (R11), BND2              // 410f1a13
+       //TODO: BNDLDX (BX), BND3               // 0f1a1b
+       //TODO: BNDLDX (R11), BND3              // 410f1a1b
+       //TODO: BNDMK (BX), BND2                // f30f1b13
+       //TODO: BNDMK (R11), BND2               // f3410f1b13
+       //TODO: BNDMK (BX), BND3                // f30f1b1b
+       //TODO: BNDMK (R11), BND3               // f3410f1b1b
+       //TODO: BNDMOV (BX), BND2               // 660f1a13
+       //TODO: BNDMOV (R11), BND2              // 66410f1a13
+       //TODO: BNDMOV BND2, BND2               // 660f1ad2 or 660f1bd2
+       //TODO: BNDMOV BND3, BND2               // 660f1ad3 or 660f1bda
+       //TODO: BNDMOV (BX), BND3               // 660f1a1b
+       //TODO: BNDMOV (R11), BND3              // 66410f1a1b
+       //TODO: BNDMOV BND2, BND3               // 660f1ada or 660f1bd3
+       //TODO: BNDMOV BND3, BND3               // 660f1adb or 660f1bdb
+       //TODO: BNDMOV BND2, (BX)               // 660f1b13
+       //TODO: BNDMOV BND3, (BX)               // 660f1b1b
+       //TODO: BNDMOV BND2, (R11)              // 66410f1b13
+       //TODO: BNDMOV BND3, (R11)              // 66410f1b1b
+       //TODO: BNDSTX BND2, (BX)               // 0f1b13
+       //TODO: BNDSTX BND3, (BX)               // 0f1b1b
+       //TODO: BNDSTX BND2, (R11)              // 410f1b13
+       //TODO: BNDSTX BND3, (R11)              // 410f1b1b
+       BSFW (BX), DX                           // 660fbc13
+       BSFW (R11), DX                          // 66410fbc13
+       BSFW DX, DX                             // 660fbcd2
+       BSFW R11, DX                            // 66410fbcd3
+       BSFW (BX), R11                          // 66440fbc1b
+       BSFW (R11), R11                         // 66450fbc1b
+       BSFW DX, R11                            // 66440fbcda
+       BSFW R11, R11                           // 66450fbcdb
+       BSFL (BX), DX                           // 0fbc13
+       BSFL (R11), DX                          // 410fbc13
+       BSFL DX, DX                             // 0fbcd2
+       BSFL R11, DX                            // 410fbcd3
+       BSFL (BX), R11                          // 440fbc1b
+       BSFL (R11), R11                         // 450fbc1b
+       BSFL DX, R11                            // 440fbcda
+       BSFL R11, R11                           // 450fbcdb
+       BSFQ (BX), DX                           // 480fbc13
+       BSFQ (R11), DX                          // 490fbc13
+       BSFQ DX, DX                             // 480fbcd2
+       BSFQ R11, DX                            // 490fbcd3
+       BSFQ (BX), R11                          // 4c0fbc1b
+       BSFQ (R11), R11                         // 4d0fbc1b
+       BSFQ DX, R11                            // 4c0fbcda
+       BSFQ R11, R11                           // 4d0fbcdb
+       BSRW (BX), DX                           // 660fbd13
+       BSRW (R11), DX                          // 66410fbd13
+       BSRW DX, DX                             // 660fbdd2
+       BSRW R11, DX                            // 66410fbdd3
+       BSRW (BX), R11                          // 66440fbd1b
+       BSRW (R11), R11                         // 66450fbd1b
+       BSRW DX, R11                            // 66440fbdda
+       BSRW R11, R11                           // 66450fbddb
+       BSRL (BX), DX                           // 0fbd13
+       BSRL (R11), DX                          // 410fbd13
+       BSRL DX, DX                             // 0fbdd2
+       BSRL R11, DX                            // 410fbdd3
+       BSRL (BX), R11                          // 440fbd1b
+       BSRL (R11), R11                         // 450fbd1b
+       BSRL DX, R11                            // 440fbdda
+       BSRL R11, R11                           // 450fbddb
+       BSRQ (BX), DX                           // 480fbd13
+       BSRQ (R11), DX                          // 490fbd13
+       BSRQ DX, DX                             // 480fbdd2
+       BSRQ R11, DX                            // 490fbdd3
+       BSRQ (BX), R11                          // 4c0fbd1b
+       BSRQ (R11), R11                         // 4d0fbd1b
+       BSRQ DX, R11                            // 4c0fbdda
+       BSRQ R11, R11                           // 4d0fbddb
+       //TODO: BSWAPW DX                       // 660fca
+       //TODO: BSWAPW R11                      // 66410fcb
+       BSWAPL DX                               // 0fca
+       BSWAPL R11                              // 410fcb
+       BSWAPQ DX                               // 480fca
+       BSWAPQ R11                              // 490fcb
+       BTW $7, (BX)                            // 660fba2307
+       BTW $7, (R11)                           // 66410fba2307
+       BTW $7, DX                              // 660fbae207
+       BTW $7, R11                             // 66410fbae307
+       BTW DX, (BX)                            // 660fa313
+       BTW R11, (BX)                           // 66440fa31b
+       BTW DX, (R11)                           // 66410fa313
+       BTW R11, (R11)                          // 66450fa31b
+       BTW DX, DX                              // 660fa3d2
+       BTW R11, DX                             // 66440fa3da
+       BTW DX, R11                             // 66410fa3d3
+       BTW R11, R11                            // 66450fa3db
+       BTL $7, (BX)                            // 0fba2307
+       BTL $7, (R11)                           // 410fba2307
+       BTL $7, DX                              // 0fbae207
+       BTL $7, R11                             // 410fbae307
+       BTL DX, (BX)                            // 0fa313
+       BTL R11, (BX)                           // 440fa31b
+       BTL DX, (R11)                           // 410fa313
+       BTL R11, (R11)                          // 450fa31b
+       BTL DX, DX                              // 0fa3d2
+       BTL R11, DX                             // 440fa3da
+       BTL DX, R11                             // 410fa3d3
+       BTL R11, R11                            // 450fa3db
+       BTQ $7, (BX)                            // 480fba2307
+       BTQ $7, (R11)                           // 490fba2307
+       BTQ $7, DX                              // 480fbae207
+       BTQ $7, R11                             // 490fbae307
+       BTQ DX, (BX)                            // 480fa313
+       BTQ R11, (BX)                           // 4c0fa31b
+       BTQ DX, (R11)                           // 490fa313
+       BTQ R11, (R11)                          // 4d0fa31b
+       BTQ DX, DX                              // 480fa3d2
+       BTQ R11, DX                             // 4c0fa3da
+       BTQ DX, R11                             // 490fa3d3
+       BTQ R11, R11                            // 4d0fa3db
+       BTCW $7, (BX)                           // 660fba3b07
+       BTCW $7, (R11)                          // 66410fba3b07
+       BTCW $7, DX                             // 660fbafa07
+       BTCW $7, R11                            // 66410fbafb07
+       BTCW DX, (BX)                           // 660fbb13
+       BTCW R11, (BX)                          // 66440fbb1b
+       BTCW DX, (R11)                          // 66410fbb13
+       BTCW R11, (R11)                         // 66450fbb1b
+       BTCW DX, DX                             // 660fbbd2
+       BTCW R11, DX                            // 66440fbbda
+       BTCW DX, R11                            // 66410fbbd3
+       BTCW R11, R11                           // 66450fbbdb
+       BTCL $7, (BX)                           // 0fba3b07
+       BTCL $7, (R11)                          // 410fba3b07
+       BTCL $7, DX                             // 0fbafa07
+       BTCL $7, R11                            // 410fbafb07
+       BTCL DX, (BX)                           // 0fbb13
+       BTCL R11, (BX)                          // 440fbb1b
+       BTCL DX, (R11)                          // 410fbb13
+       BTCL R11, (R11)                         // 450fbb1b
+       BTCL DX, DX                             // 0fbbd2
+       BTCL R11, DX                            // 440fbbda
+       BTCL DX, R11                            // 410fbbd3
+       BTCL R11, R11                           // 450fbbdb
+       BTCQ $7, (BX)                           // 480fba3b07
+       BTCQ $7, (R11)                          // 490fba3b07
+       BTCQ $7, DX                             // 480fbafa07
+       BTCQ $7, R11                            // 490fbafb07
+       BTCQ DX, (BX)                           // 480fbb13
+       BTCQ R11, (BX)                          // 4c0fbb1b
+       BTCQ DX, (R11)                          // 490fbb13
+       BTCQ R11, (R11)                         // 4d0fbb1b
+       BTCQ DX, DX                             // 480fbbd2
+       BTCQ R11, DX                            // 4c0fbbda
+       BTCQ DX, R11                            // 490fbbd3
+       BTCQ R11, R11                           // 4d0fbbdb
+       BTRW $7, (BX)                           // 660fba3307
+       BTRW $7, (R11)                          // 66410fba3307
+       BTRW $7, DX                             // 660fbaf207
+       BTRW $7, R11                            // 66410fbaf307
+       BTRW DX, (BX)                           // 660fb313
+       BTRW R11, (BX)                          // 66440fb31b
+       BTRW DX, (R11)                          // 66410fb313
+       BTRW R11, (R11)                         // 66450fb31b
+       BTRW DX, DX                             // 660fb3d2
+       BTRW R11, DX                            // 66440fb3da
+       BTRW DX, R11                            // 66410fb3d3
+       BTRW R11, R11                           // 66450fb3db
+       BTRL $7, (BX)                           // 0fba3307
+       BTRL $7, (R11)                          // 410fba3307
+       BTRL $7, DX                             // 0fbaf207
+       BTRL $7, R11                            // 410fbaf307
+       BTRL DX, (BX)                           // 0fb313
+       BTRL R11, (BX)                          // 440fb31b
+       BTRL DX, (R11)                          // 410fb313
+       BTRL R11, (R11)                         // 450fb31b
+       BTRL DX, DX                             // 0fb3d2
+       BTRL R11, DX                            // 440fb3da
+       BTRL DX, R11                            // 410fb3d3
+       BTRL R11, R11                           // 450fb3db
+       BTRQ $7, (BX)                           // 480fba3307
+       BTRQ $7, (R11)                          // 490fba3307
+       BTRQ $7, DX                             // 480fbaf207
+       BTRQ $7, R11                            // 490fbaf307
+       BTRQ DX, (BX)                           // 480fb313
+       BTRQ R11, (BX)                          // 4c0fb31b
+       BTRQ DX, (R11)                          // 490fb313
+       BTRQ R11, (R11)                         // 4d0fb31b
+       BTRQ DX, DX                             // 480fb3d2
+       BTRQ R11, DX                            // 4c0fb3da
+       BTRQ DX, R11                            // 490fb3d3
+       BTRQ R11, R11                           // 4d0fb3db
+       BTSW $7, (BX)                           // 660fba2b07
+       BTSW $7, (R11)                          // 66410fba2b07
+       BTSW $7, DX                             // 660fbaea07
+       BTSW $7, R11                            // 66410fbaeb07
+       BTSW DX, (BX)                           // 660fab13
+       BTSW R11, (BX)                          // 66440fab1b
+       BTSW DX, (R11)                          // 66410fab13
+       BTSW R11, (R11)                         // 66450fab1b
+       BTSW DX, DX                             // 660fabd2
+       BTSW R11, DX                            // 66440fabda
+       BTSW DX, R11                            // 66410fabd3
+       BTSW R11, R11                           // 66450fabdb
+       BTSL $7, (BX)                           // 0fba2b07
+       BTSL $7, (R11)                          // 410fba2b07
+       BTSL $7, DX                             // 0fbaea07
+       BTSL $7, R11                            // 410fbaeb07
+       BTSL DX, (BX)                           // 0fab13
+       BTSL R11, (BX)                          // 440fab1b
+       BTSL DX, (R11)                          // 410fab13
+       BTSL R11, (R11)                         // 450fab1b
+       BTSL DX, DX                             // 0fabd2
+       BTSL R11, DX                            // 440fabda
+       BTSL DX, R11                            // 410fabd3
+       BTSL R11, R11                           // 450fabdb
+       BTSQ $7, (BX)                           // 480fba2b07
+       BTSQ $7, (R11)                          // 490fba2b07
+       BTSQ $7, DX                             // 480fbaea07
+       BTSQ $7, R11                            // 490fbaeb07
+       BTSQ DX, (BX)                           // 480fab13
+       BTSQ R11, (BX)                          // 4c0fab1b
+       BTSQ DX, (R11)                          // 490fab13
+       BTSQ R11, (R11)                         // 4d0fab1b
+       BTSQ DX, DX                             // 480fabd2
+       BTSQ R11, DX                            // 4c0fabda
+       BTSQ DX, R11                            // 490fabd3
+       BTSQ R11, R11                           // 4d0fabdb
+       BZHIL R9, (BX), DX                      // c4e230f513
+       BZHIL R9, (R11), DX                     // c4c230f513
+       BZHIL R9, DX, DX                        // c4e230f5d2
+       BZHIL R9, R11, DX                       // c4c230f5d3
+       BZHIL R9, (BX), R11                     // c46230f51b
+       BZHIL R9, (R11), R11                    // c44230f51b
+       BZHIL R9, DX, R11                       // c46230f5da
+       BZHIL R9, R11, R11                      // c44230f5db
+       BZHIQ R14, (BX), DX                     // c4e288f513
+       BZHIQ R14, (R11), DX                    // c4c288f513
+       BZHIQ R14, DX, DX                       // c4e288f5d2
+       BZHIQ R14, R11, DX                      // c4c288f5d3
+       BZHIQ R14, (BX), R11                    // c46288f51b
+       BZHIQ R14, (R11), R11                   // c44288f51b
+       BZHIQ R14, DX, R11                      // c46288f5da
+       BZHIQ R14, R11, R11                     // c44288f5db
+       //TODO: CALLQ* (BX)                     // ff13
+       //TODO: CALLQ* (R11)                    // 41ff13
+       //TODO: CALLQ* DX                       // ffd2
+       //TODO: CALLQ* R11                      // 41ffd3
+       //TODO: CALL .+$0x11223344              // e844332211 or 48e844332211
+       //TODO: LCALLW* (BX)                    // 66ff1b
+       //TODO: LCALLW* (R11)                   // 6641ff1b
+       //TODO: LCALLL* (BX)                    // ff1b
+       //TODO: LCALLL* (R11)                   // 41ff1b
+       //TODO: LCALLQ* (BX)                    // 48ff1b
+       //TODO: LCALLQ* (R11)                   // 49ff1b
+       //TODO: CBW                             // 6698
+       CDQ                                     // 99
+       //TODO: CDQE                            // 4898
+       //TODO: CLAC                            // 0f01ca
+       CLC                                     // f8
+       CLD                                     // fc
+       //TODO: CLFLUSH (BX)                    // 0fae3b
+       //TODO: CLFLUSH (R11)                   // 410fae3b
+       //TODO: CLFLUSHOPT (BX)                 // 660fae3b
+       //TODO: CLFLUSHOPT (R11)                // 66410fae3b
+       CLI                                     // fa
+       CLTS                                    // 0f06
+       CMC                                     // f5
+       CMOVWHI (BX), DX                        // 660f4713
+       CMOVWHI (R11), DX                       // 66410f4713
+       CMOVWHI DX, DX                          // 660f47d2
+       CMOVWHI R11, DX                         // 66410f47d3
+       CMOVWHI (BX), R11                       // 66440f471b
+       CMOVWHI (R11), R11                      // 66450f471b
+       CMOVWHI DX, R11                         // 66440f47da
+       CMOVWHI R11, R11                        // 66450f47db
+       CMOVLHI (BX), DX                        // 0f4713
+       CMOVLHI (R11), DX                       // 410f4713
+       CMOVLHI DX, DX                          // 0f47d2
+       CMOVLHI R11, DX                         // 410f47d3
+       CMOVLHI (BX), R11                       // 440f471b
+       CMOVLHI (R11), R11                      // 450f471b
+       CMOVLHI DX, R11                         // 440f47da
+       CMOVLHI R11, R11                        // 450f47db
+       CMOVQHI (BX), DX                        // 480f4713
+       CMOVQHI (R11), DX                       // 490f4713
+       CMOVQHI DX, DX                          // 480f47d2
+       CMOVQHI R11, DX                         // 490f47d3
+       CMOVQHI (BX), R11                       // 4c0f471b
+       CMOVQHI (R11), R11                      // 4d0f471b
+       CMOVQHI DX, R11                         // 4c0f47da
+       CMOVQHI R11, R11                        // 4d0f47db
+       CMOVWCC (BX), DX                        // 660f4313
+       CMOVWCC (R11), DX                       // 66410f4313
+       CMOVWCC DX, DX                          // 660f43d2
+       CMOVWCC R11, DX                         // 66410f43d3
+       CMOVWCC (BX), R11                       // 66440f431b
+       CMOVWCC (R11), R11                      // 66450f431b
+       CMOVWCC DX, R11                         // 66440f43da
+       CMOVWCC R11, R11                        // 66450f43db
+       CMOVLCC (BX), DX                        // 0f4313
+       CMOVLCC (R11), DX                       // 410f4313
+       CMOVLCC DX, DX                          // 0f43d2
+       CMOVLCC R11, DX                         // 410f43d3
+       CMOVLCC (BX), R11                       // 440f431b
+       CMOVLCC (R11), R11                      // 450f431b
+       CMOVLCC DX, R11                         // 440f43da
+       CMOVLCC R11, R11                        // 450f43db
+       CMOVQCC (BX), DX                        // 480f4313
+       CMOVQCC (R11), DX                       // 490f4313
+       CMOVQCC DX, DX                          // 480f43d2
+       CMOVQCC R11, DX                         // 490f43d3
+       CMOVQCC (BX), R11                       // 4c0f431b
+       CMOVQCC (R11), R11                      // 4d0f431b
+       CMOVQCC DX, R11                         // 4c0f43da
+       CMOVQCC R11, R11                        // 4d0f43db
+       CMOVWCS (BX), DX                        // 660f4213
+       CMOVWCS (R11), DX                       // 66410f4213
+       CMOVWCS DX, DX                          // 660f42d2
+       CMOVWCS R11, DX                         // 66410f42d3
+       CMOVWCS (BX), R11                       // 66440f421b
+       CMOVWCS (R11), R11                      // 66450f421b
+       CMOVWCS DX, R11                         // 66440f42da
+       CMOVWCS R11, R11                        // 66450f42db
+       CMOVLCS (BX), DX                        // 0f4213
+       CMOVLCS (R11), DX                       // 410f4213
+       CMOVLCS DX, DX                          // 0f42d2
+       CMOVLCS R11, DX                         // 410f42d3
+       CMOVLCS (BX), R11                       // 440f421b
+       CMOVLCS (R11), R11                      // 450f421b
+       CMOVLCS DX, R11                         // 440f42da
+       CMOVLCS R11, R11                        // 450f42db
+       CMOVQCS (BX), DX                        // 480f4213
+       CMOVQCS (R11), DX                       // 490f4213
+       CMOVQCS DX, DX                          // 480f42d2
+       CMOVQCS R11, DX                         // 490f42d3
+       CMOVQCS (BX), R11                       // 4c0f421b
+       CMOVQCS (R11), R11                      // 4d0f421b
+       CMOVQCS DX, R11                         // 4c0f42da
+       CMOVQCS R11, R11                        // 4d0f42db
+       CMOVWLS (BX), DX                        // 660f4613
+       CMOVWLS (R11), DX                       // 66410f4613
+       CMOVWLS DX, DX                          // 660f46d2
+       CMOVWLS R11, DX                         // 66410f46d3
+       CMOVWLS (BX), R11                       // 66440f461b
+       CMOVWLS (R11), R11                      // 66450f461b
+       CMOVWLS DX, R11                         // 66440f46da
+       CMOVWLS R11, R11                        // 66450f46db
+       CMOVLLS (BX), DX                        // 0f4613
+       CMOVLLS (R11), DX                       // 410f4613
+       CMOVLLS DX, DX                          // 0f46d2
+       CMOVLLS R11, DX                         // 410f46d3
+       CMOVLLS (BX), R11                       // 440f461b
+       CMOVLLS (R11), R11                      // 450f461b
+       CMOVLLS DX, R11                         // 440f46da
+       CMOVLLS R11, R11                        // 450f46db
+       CMOVQLS (BX), DX                        // 480f4613
+       CMOVQLS (R11), DX                       // 490f4613
+       CMOVQLS DX, DX                          // 480f46d2
+       CMOVQLS R11, DX                         // 490f46d3
+       CMOVQLS (BX), R11                       // 4c0f461b
+       CMOVQLS (R11), R11                      // 4d0f461b
+       CMOVQLS DX, R11                         // 4c0f46da
+       CMOVQLS R11, R11                        // 4d0f46db
+       CMOVWEQ (BX), DX                        // 660f4413
+       CMOVWEQ (R11), DX                       // 66410f4413
+       CMOVWEQ DX, DX                          // 660f44d2
+       CMOVWEQ R11, DX                         // 66410f44d3
+       CMOVWEQ (BX), R11                       // 66440f441b
+       CMOVWEQ (R11), R11                      // 66450f441b
+       CMOVWEQ DX, R11                         // 66440f44da
+       CMOVWEQ R11, R11                        // 66450f44db
+       CMOVLEQ (BX), DX                        // 0f4413
+       CMOVLEQ (R11), DX                       // 410f4413
+       CMOVLEQ DX, DX                          // 0f44d2
+       CMOVLEQ R11, DX                         // 410f44d3
+       CMOVLEQ (BX), R11                       // 440f441b
+       CMOVLEQ (R11), R11                      // 450f441b
+       CMOVLEQ DX, R11                         // 440f44da
+       CMOVLEQ R11, R11                        // 450f44db
+       CMOVQEQ (BX), DX                        // 480f4413
+       CMOVQEQ (R11), DX                       // 490f4413
+       CMOVQEQ DX, DX                          // 480f44d2
+       CMOVQEQ R11, DX                         // 490f44d3
+       CMOVQEQ (BX), R11                       // 4c0f441b
+       CMOVQEQ (R11), R11                      // 4d0f441b
+       CMOVQEQ DX, R11                         // 4c0f44da
+       CMOVQEQ R11, R11                        // 4d0f44db
+       CMOVWGT (BX), DX                        // 660f4f13
+       CMOVWGT (R11), DX                       // 66410f4f13
+       CMOVWGT DX, DX                          // 660f4fd2
+       CMOVWGT R11, DX                         // 66410f4fd3
+       CMOVWGT (BX), R11                       // 66440f4f1b
+       CMOVWGT (R11), R11                      // 66450f4f1b
+       CMOVWGT DX, R11                         // 66440f4fda
+       CMOVWGT R11, R11                        // 66450f4fdb
+       CMOVLGT (BX), DX                        // 0f4f13
+       CMOVLGT (R11), DX                       // 410f4f13
+       CMOVLGT DX, DX                          // 0f4fd2
+       CMOVLGT R11, DX                         // 410f4fd3
+       CMOVLGT (BX), R11                       // 440f4f1b
+       CMOVLGT (R11), R11                      // 450f4f1b
+       CMOVLGT DX, R11                         // 440f4fda
+       CMOVLGT R11, R11                        // 450f4fdb
+       CMOVQGT (BX), DX                        // 480f4f13
+       CMOVQGT (R11), DX                       // 490f4f13
+       CMOVQGT DX, DX                          // 480f4fd2
+       CMOVQGT R11, DX                         // 490f4fd3
+       CMOVQGT (BX), R11                       // 4c0f4f1b
+       CMOVQGT (R11), R11                      // 4d0f4f1b
+       CMOVQGT DX, R11                         // 4c0f4fda
+       CMOVQGT R11, R11                        // 4d0f4fdb
+       CMOVWGE (BX), DX                        // 660f4d13
+       CMOVWGE (R11), DX                       // 66410f4d13
+       CMOVWGE DX, DX                          // 660f4dd2
+       CMOVWGE R11, DX                         // 66410f4dd3
+       CMOVWGE (BX), R11                       // 66440f4d1b
+       CMOVWGE (R11), R11                      // 66450f4d1b
+       CMOVWGE DX, R11                         // 66440f4dda
+       CMOVWGE R11, R11                        // 66450f4ddb
+       CMOVLGE (BX), DX                        // 0f4d13
+       CMOVLGE (R11), DX                       // 410f4d13
+       CMOVLGE DX, DX                          // 0f4dd2
+       CMOVLGE R11, DX                         // 410f4dd3
+       CMOVLGE (BX), R11                       // 440f4d1b
+       CMOVLGE (R11), R11                      // 450f4d1b
+       CMOVLGE DX, R11                         // 440f4dda
+       CMOVLGE R11, R11                        // 450f4ddb
+       CMOVQGE (BX), DX                        // 480f4d13
+       CMOVQGE (R11), DX                       // 490f4d13
+       CMOVQGE DX, DX                          // 480f4dd2
+       CMOVQGE R11, DX                         // 490f4dd3
+       CMOVQGE (BX), R11                       // 4c0f4d1b
+       CMOVQGE (R11), R11                      // 4d0f4d1b
+       CMOVQGE DX, R11                         // 4c0f4dda
+       CMOVQGE R11, R11                        // 4d0f4ddb
+       CMOVWLT (BX), DX                        // 660f4c13
+       CMOVWLT (R11), DX                       // 66410f4c13
+       CMOVWLT DX, DX                          // 660f4cd2
+       CMOVWLT R11, DX                         // 66410f4cd3
+       CMOVWLT (BX), R11                       // 66440f4c1b
+       CMOVWLT (R11), R11                      // 66450f4c1b
+       CMOVWLT DX, R11                         // 66440f4cda
+       CMOVWLT R11, R11                        // 66450f4cdb
+       CMOVLLT (BX), DX                        // 0f4c13
+       CMOVLLT (R11), DX                       // 410f4c13
+       CMOVLLT DX, DX                          // 0f4cd2
+       CMOVLLT R11, DX                         // 410f4cd3
+       CMOVLLT (BX), R11                       // 440f4c1b
+       CMOVLLT (R11), R11                      // 450f4c1b
+       CMOVLLT DX, R11                         // 440f4cda
+       CMOVLLT R11, R11                        // 450f4cdb
+       CMOVQLT (BX), DX                        // 480f4c13
+       CMOVQLT (R11), DX                       // 490f4c13
+       CMOVQLT DX, DX                          // 480f4cd2
+       CMOVQLT R11, DX                         // 490f4cd3
+       CMOVQLT (BX), R11                       // 4c0f4c1b
+       CMOVQLT (R11), R11                      // 4d0f4c1b
+       CMOVQLT DX, R11                         // 4c0f4cda
+       CMOVQLT R11, R11                        // 4d0f4cdb
+       CMOVWLE (BX), DX                        // 660f4e13
+       CMOVWLE (R11), DX                       // 66410f4e13
+       CMOVWLE DX, DX                          // 660f4ed2
+       CMOVWLE R11, DX                         // 66410f4ed3
+       CMOVWLE (BX), R11                       // 66440f4e1b
+       CMOVWLE (R11), R11                      // 66450f4e1b
+       CMOVWLE DX, R11                         // 66440f4eda
+       CMOVWLE R11, R11                        // 66450f4edb
+       CMOVLLE (BX), DX                        // 0f4e13
+       CMOVLLE (R11), DX                       // 410f4e13
+       CMOVLLE DX, DX                          // 0f4ed2
+       CMOVLLE R11, DX                         // 410f4ed3
+       CMOVLLE (BX), R11                       // 440f4e1b
+       CMOVLLE (R11), R11                      // 450f4e1b
+       CMOVLLE DX, R11                         // 440f4eda
+       CMOVLLE R11, R11                        // 450f4edb
+       CMOVQLE (BX), DX                        // 480f4e13
+       CMOVQLE (R11), DX                       // 490f4e13
+       CMOVQLE DX, DX                          // 480f4ed2
+       CMOVQLE R11, DX                         // 490f4ed3
+       CMOVQLE (BX), R11                       // 4c0f4e1b
+       CMOVQLE (R11), R11                      // 4d0f4e1b
+       CMOVQLE DX, R11                         // 4c0f4eda
+       CMOVQLE R11, R11                        // 4d0f4edb
+       CMOVWNE (BX), DX                        // 660f4513
+       CMOVWNE (R11), DX                       // 66410f4513
+       CMOVWNE DX, DX                          // 660f45d2
+       CMOVWNE R11, DX                         // 66410f45d3
+       CMOVWNE (BX), R11                       // 66440f451b
+       CMOVWNE (R11), R11                      // 66450f451b
+       CMOVWNE DX, R11                         // 66440f45da
+       CMOVWNE R11, R11                        // 66450f45db
+       CMOVLNE (BX), DX                        // 0f4513
+       CMOVLNE (R11), DX                       // 410f4513
+       CMOVLNE DX, DX                          // 0f45d2
+       CMOVLNE R11, DX                         // 410f45d3
+       CMOVLNE (BX), R11                       // 440f451b
+       CMOVLNE (R11), R11                      // 450f451b
+       CMOVLNE DX, R11                         // 440f45da
+       CMOVLNE R11, R11                        // 450f45db
+       CMOVQNE (BX), DX                        // 480f4513
+       CMOVQNE (R11), DX                       // 490f4513
+       CMOVQNE DX, DX                          // 480f45d2
+       CMOVQNE R11, DX                         // 490f45d3
+       CMOVQNE (BX), R11                       // 4c0f451b
+       CMOVQNE (R11), R11                      // 4d0f451b
+       CMOVQNE DX, R11                         // 4c0f45da
+       CMOVQNE R11, R11                        // 4d0f45db
+       CMOVWOC (BX), DX                        // 660f4113
+       CMOVWOC (R11), DX                       // 66410f4113
+       CMOVWOC DX, DX                          // 660f41d2
+       CMOVWOC R11, DX                         // 66410f41d3
+       CMOVWOC (BX), R11                       // 66440f411b
+       CMOVWOC (R11), R11                      // 66450f411b
+       CMOVWOC DX, R11                         // 66440f41da
+       CMOVWOC R11, R11                        // 66450f41db
+       CMOVLOC (BX), DX                        // 0f4113
+       CMOVLOC (R11), DX                       // 410f4113
+       CMOVLOC DX, DX                          // 0f41d2
+       CMOVLOC R11, DX                         // 410f41d3
+       CMOVLOC (BX), R11                       // 440f411b
+       CMOVLOC (R11), R11                      // 450f411b
+       CMOVLOC DX, R11                         // 440f41da
+       CMOVLOC R11, R11                        // 450f41db
+       CMOVQOC (BX), DX                        // 480f4113
+       CMOVQOC (R11), DX                       // 490f4113
+       CMOVQOC DX, DX                          // 480f41d2
+       CMOVQOC R11, DX                         // 490f41d3
+       CMOVQOC (BX), R11                       // 4c0f411b
+       CMOVQOC (R11), R11                      // 4d0f411b
+       CMOVQOC DX, R11                         // 4c0f41da
+       CMOVQOC R11, R11                        // 4d0f41db
+       CMOVWPC (BX), DX                        // 660f4b13
+       CMOVWPC (R11), DX                       // 66410f4b13
+       CMOVWPC DX, DX                          // 660f4bd2
+       CMOVWPC R11, DX                         // 66410f4bd3
+       CMOVWPC (BX), R11                       // 66440f4b1b
+       CMOVWPC (R11), R11                      // 66450f4b1b
+       CMOVWPC DX, R11                         // 66440f4bda
+       CMOVWPC R11, R11                        // 66450f4bdb
+       CMOVLPC (BX), DX                        // 0f4b13
+       CMOVLPC (R11), DX                       // 410f4b13
+       CMOVLPC DX, DX                          // 0f4bd2
+       CMOVLPC R11, DX                         // 410f4bd3
+       CMOVLPC (BX), R11                       // 440f4b1b
+       CMOVLPC (R11), R11                      // 450f4b1b
+       CMOVLPC DX, R11                         // 440f4bda
+       CMOVLPC R11, R11                        // 450f4bdb
+       CMOVQPC (BX), DX                        // 480f4b13
+       CMOVQPC (R11), DX                       // 490f4b13
+       CMOVQPC DX, DX                          // 480f4bd2
+       CMOVQPC R11, DX                         // 490f4bd3
+       CMOVQPC (BX), R11                       // 4c0f4b1b
+       CMOVQPC (R11), R11                      // 4d0f4b1b
+       CMOVQPC DX, R11                         // 4c0f4bda
+       CMOVQPC R11, R11                        // 4d0f4bdb
+       CMOVWPL (BX), DX                        // 660f4913
+       CMOVWPL (R11), DX                       // 66410f4913
+       CMOVWPL DX, DX                          // 660f49d2
+       CMOVWPL R11, DX                         // 66410f49d3
+       CMOVWPL (BX), R11                       // 66440f491b
+       CMOVWPL (R11), R11                      // 66450f491b
+       CMOVWPL DX, R11                         // 66440f49da
+       CMOVWPL R11, R11                        // 66450f49db
+       CMOVLPL (BX), DX                        // 0f4913
+       CMOVLPL (R11), DX                       // 410f4913
+       CMOVLPL DX, DX                          // 0f49d2
+       CMOVLPL R11, DX                         // 410f49d3
+       CMOVLPL (BX), R11                       // 440f491b
+       CMOVLPL (R11), R11                      // 450f491b
+       CMOVLPL DX, R11                         // 440f49da
+       CMOVLPL R11, R11                        // 450f49db
+       CMOVQPL (BX), DX                        // 480f4913
+       CMOVQPL (R11), DX                       // 490f4913
+       CMOVQPL DX, DX                          // 480f49d2
+       CMOVQPL R11, DX                         // 490f49d3
+       CMOVQPL (BX), R11                       // 4c0f491b
+       CMOVQPL (R11), R11                      // 4d0f491b
+       CMOVQPL DX, R11                         // 4c0f49da
+       CMOVQPL R11, R11                        // 4d0f49db
+       CMOVWOS (BX), DX                        // 660f4013
+       CMOVWOS (R11), DX                       // 66410f4013
+       CMOVWOS DX, DX                          // 660f40d2
+       CMOVWOS R11, DX                         // 66410f40d3
+       CMOVWOS (BX), R11                       // 66440f401b
+       CMOVWOS (R11), R11                      // 66450f401b
+       CMOVWOS DX, R11                         // 66440f40da
+       CMOVWOS R11, R11                        // 66450f40db
+       CMOVLOS (BX), DX                        // 0f4013
+       CMOVLOS (R11), DX                       // 410f4013
+       CMOVLOS DX, DX                          // 0f40d2
+       CMOVLOS R11, DX                         // 410f40d3
+       CMOVLOS (BX), R11                       // 440f401b
+       CMOVLOS (R11), R11                      // 450f401b
+       CMOVLOS DX, R11                         // 440f40da
+       CMOVLOS R11, R11                        // 450f40db
+       CMOVQOS (BX), DX                        // 480f4013
+       CMOVQOS (R11), DX                       // 490f4013
+       CMOVQOS DX, DX                          // 480f40d2
+       CMOVQOS R11, DX                         // 490f40d3
+       CMOVQOS (BX), R11                       // 4c0f401b
+       CMOVQOS (R11), R11                      // 4d0f401b
+       CMOVQOS DX, R11                         // 4c0f40da
+       CMOVQOS R11, R11                        // 4d0f40db
+       CMOVWPS (BX), DX                        // 660f4a13
+       CMOVWPS (R11), DX                       // 66410f4a13
+       CMOVWPS DX, DX                          // 660f4ad2
+       CMOVWPS R11, DX                         // 66410f4ad3
+       CMOVWPS (BX), R11                       // 66440f4a1b
+       CMOVWPS (R11), R11                      // 66450f4a1b
+       CMOVWPS DX, R11                         // 66440f4ada
+       CMOVWPS R11, R11                        // 66450f4adb
+       CMOVLPS (BX), DX                        // 0f4a13
+       CMOVLPS (R11), DX                       // 410f4a13
+       CMOVLPS DX, DX                          // 0f4ad2
+       CMOVLPS R11, DX                         // 410f4ad3
+       CMOVLPS (BX), R11                       // 440f4a1b
+       CMOVLPS (R11), R11                      // 450f4a1b
+       CMOVLPS DX, R11                         // 440f4ada
+       CMOVLPS R11, R11                        // 450f4adb
+       CMOVQPS (BX), DX                        // 480f4a13
+       CMOVQPS (R11), DX                       // 490f4a13
+       CMOVQPS DX, DX                          // 480f4ad2
+       CMOVQPS R11, DX                         // 490f4ad3
+       CMOVQPS (BX), R11                       // 4c0f4a1b
+       CMOVQPS (R11), R11                      // 4d0f4a1b
+       CMOVQPS DX, R11                         // 4c0f4ada
+       CMOVQPS R11, R11                        // 4d0f4adb
+       CMOVWMI (BX), DX                        // 660f4813
+       CMOVWMI (R11), DX                       // 66410f4813
+       CMOVWMI DX, DX                          // 660f48d2
+       CMOVWMI R11, DX                         // 66410f48d3
+       CMOVWMI (BX), R11                       // 66440f481b
+       CMOVWMI (R11), R11                      // 66450f481b
+       CMOVWMI DX, R11                         // 66440f48da
+       CMOVWMI R11, R11                        // 66450f48db
+       CMOVLMI (BX), DX                        // 0f4813
+       CMOVLMI (R11), DX                       // 410f4813
+       CMOVLMI DX, DX                          // 0f48d2
+       CMOVLMI R11, DX                         // 410f48d3
+       CMOVLMI (BX), R11                       // 440f481b
+       CMOVLMI (R11), R11                      // 450f481b
+       CMOVLMI DX, R11                         // 440f48da
+       CMOVLMI R11, R11                        // 450f48db
+       CMOVQMI (BX), DX                        // 480f4813
+       CMOVQMI (R11), DX                       // 490f4813
+       CMOVQMI DX, DX                          // 480f48d2
+       CMOVQMI R11, DX                         // 490f48d3
+       CMOVQMI (BX), R11                       // 4c0f481b
+       CMOVQMI (R11), R11                      // 4d0f481b
+       CMOVQMI DX, R11                         // 4c0f48da
+       CMOVQMI R11, R11                        // 4d0f48db
+       CMPB AL, $7                             // 3c07
+       CMPW AX, $61731                         // 663d23f1
+       CMPL AX, $4045620583                    // 3d674523f1
+       CMPQ AX, $-249346713                    // 483d674523f1
+       CMPW (BX), $61731                       // 66813b23f1
+       CMPW (R11), $61731                      // 6641813b23f1
+       CMPW DX, $61731                         // 6681fa23f1
+       CMPW R11, $61731                        // 664181fb23f1
+       CMPW (BX), $7                           // 66833b07
+       CMPW (R11), $7                          // 6641833b07
+       CMPW DX, $7                             // 6683fa07
+       CMPW R11, $7                            // 664183fb07
+       CMPW (BX), DX                           // 663913
+       CMPW (BX), R11                          // 6644391b
+       CMPW (R11), DX                          // 66413913
+       CMPW (R11), R11                         // 6645391b
+       CMPW DX, DX                             // 6639d2 or 663bd2
+       CMPW DX, R11                            // 664439da or 66413bd3
+       CMPW R11, DX                            // 664139d3 or 66443bda
+       CMPW R11, R11                           // 664539db or 66453bdb
+       CMPL (BX), $4045620583                  // 813b674523f1
+       CMPL (R11), $4045620583                 // 41813b674523f1
+       CMPL DX, $4045620583                    // 81fa674523f1
+       CMPL R11, $4045620583                   // 4181fb674523f1
+       CMPL (BX), $7                           // 833b07
+       CMPL (R11), $7                          // 41833b07
+       CMPL DX, $7                             // 83fa07
+       CMPL R11, $7                            // 4183fb07
+       CMPL (BX), DX                           // 3913
+       CMPL (BX), R11                          // 44391b
+       CMPL (R11), DX                          // 413913
+       CMPL (R11), R11                         // 45391b
+       CMPL DX, DX                             // 39d2 or 3bd2
+       CMPL DX, R11                            // 4439da or 413bd3
+       CMPL R11, DX                            // 4139d3 or 443bda
+       CMPL R11, R11                           // 4539db or 453bdb
+       CMPQ (BX), $-249346713                  // 48813b674523f1
+       CMPQ (R11), $-249346713                 // 49813b674523f1
+       CMPQ DX, $-249346713                    // 4881fa674523f1
+       CMPQ R11, $-249346713                   // 4981fb674523f1
+       CMPQ (BX), $7                           // 48833b07
+       CMPQ (R11), $7                          // 49833b07
+       CMPQ DX, $7                             // 4883fa07
+       CMPQ R11, $7                            // 4983fb07
+       CMPQ (BX), DX                           // 483913
+       CMPQ (BX), R11                          // 4c391b
+       CMPQ (R11), DX                          // 493913
+       CMPQ (R11), R11                         // 4d391b
+       CMPQ DX, DX                             // 4839d2 or 483bd2
+       CMPQ DX, R11                            // 4c39da or 493bd3
+       CMPQ R11, DX                            // 4939d3 or 4c3bda
+       CMPQ R11, R11                           // 4d39db or 4d3bdb
+       CMPB (BX), $7                           // 803b07
+       CMPB (R11), $7                          // 41803b07
+       CMPB DL, $7                             // 80fa07
+       CMPB R11, $7                            // 4180fb07
+       CMPB (BX), DL                           // 3813
+       CMPB (BX), R11                          // 44381b
+       CMPB (R11), DL                          // 413813
+       CMPB (R11), R11                         // 45381b
+       CMPB DL, DL                             // 38d2 or 3ad2
+       CMPB DL, R11                            // 4438da or 413ad3
+       CMPB R11, DL                            // 4138d3 or 443ada
+       CMPB R11, R11                           // 4538db or 453adb
+       CMPW DX, (BX)                           // 663b13
+       CMPW DX, (R11)                          // 66413b13
+       CMPW R11, (BX)                          // 66443b1b
+       CMPW R11, (R11)                         // 66453b1b
+       CMPL DX, (BX)                           // 3b13
+       CMPL DX, (R11)                          // 413b13
+       CMPL R11, (BX)                          // 443b1b
+       CMPL R11, (R11)                         // 453b1b
+       CMPQ DX, (BX)                           // 483b13
+       CMPQ DX, (R11)                          // 493b13
+       CMPQ R11, (BX)                          // 4c3b1b
+       CMPQ R11, (R11)                         // 4d3b1b
+       CMPB DL, (BX)                           // 3a13
+       CMPB DL, (R11)                          // 413a13
+       CMPB R11, (BX)                          // 443a1b
+       CMPB R11, (R11)                         // 453a1b
+       //TODO: CMPPD $7, X2, (BX)              // 660fc21307
+       //TODO: CMPPD $7, X2, (R11)             // 66410fc21307
+       //TODO: CMPPD $7, X2, X2                // 660fc2d207
+       //TODO: CMPPD $7, X2, X11               // 66410fc2d307
+       //TODO: CMPPD $7, X11, (BX)             // 66440fc21b07
+       //TODO: CMPPD $7, X11, (R11)            // 66450fc21b07
+       //TODO: CMPPD $7, X11, X2               // 66440fc2da07
+       //TODO: CMPPD $7, X11, X11              // 66450fc2db07
+       //TODO: CMPPS $7, X2, (BX)              // 0fc21307
+       //TODO: CMPPS $7, X2, (R11)             // 410fc21307
+       //TODO: CMPPS $7, X2, X2                // 0fc2d207
+       //TODO: CMPPS $7, X2, X11               // 410fc2d307
+       //TODO: CMPPS $7, X11, (BX)             // 440fc21b07
+       //TODO: CMPPS $7, X11, (R11)            // 450fc21b07
+       //TODO: CMPPS $7, X11, X2               // 440fc2da07
+       //TODO: CMPPS $7, X11, X11              // 450fc2db07
+       CMPSB                                   // a6
+       CMPSL                                   // a7
+       //TODO: CMPSD $7, X2, (BX)              // f20fc21307
+       //TODO: CMPSD $7, X2, (R11)             // f2410fc21307
+       //TODO: CMPSD $7, X2, X2                // f20fc2d207
+       //TODO: CMPSD $7, X2, X11               // f2410fc2d307
+       //TODO: CMPSD $7, X11, (BX)             // f2440fc21b07
+       //TODO: CMPSD $7, X11, (R11)            // f2450fc21b07
+       //TODO: CMPSD $7, X11, X2               // f2440fc2da07
+       //TODO: CMPSD $7, X11, X11              // f2450fc2db07
+       CMPSQ                                   // 48a7
+       //TODO: CMPSS $7, X2, (BX)              // f30fc21307
+       //TODO: CMPSS $7, X2, (R11)             // f3410fc21307
+       //TODO: CMPSS $7, X2, X2                // f30fc2d207
+       //TODO: CMPSS $7, X2, X11               // f3410fc2d307
+       //TODO: CMPSS $7, X11, (BX)             // f3440fc21b07
+       //TODO: CMPSS $7, X11, (R11)            // f3450fc21b07
+       //TODO: CMPSS $7, X11, X2               // f3440fc2da07
+       //TODO: CMPSS $7, X11, X11              // f3450fc2db07
+       CMPSW                                   // 66a7
+       CMPXCHGW DX, (BX)                       // 660fb113
+       CMPXCHGW R11, (BX)                      // 66440fb11b
+       CMPXCHGW DX, (R11)                      // 66410fb113
+       CMPXCHGW R11, (R11)                     // 66450fb11b
+       CMPXCHGW DX, DX                         // 660fb1d2
+       CMPXCHGW R11, DX                        // 66440fb1da
+       CMPXCHGW DX, R11                        // 66410fb1d3
+       CMPXCHGW R11, R11                       // 66450fb1db
+       CMPXCHGL DX, (BX)                       // 0fb113
+       CMPXCHGL R11, (BX)                      // 440fb11b
+       CMPXCHGL DX, (R11)                      // 410fb113
+       CMPXCHGL R11, (R11)                     // 450fb11b
+       CMPXCHGL DX, DX                         // 0fb1d2
+       CMPXCHGL R11, DX                        // 440fb1da
+       CMPXCHGL DX, R11                        // 410fb1d3
+       CMPXCHGL R11, R11                       // 450fb1db
+       CMPXCHGQ DX, (BX)                       // 480fb113
+       CMPXCHGQ R11, (BX)                      // 4c0fb11b
+       CMPXCHGQ DX, (R11)                      // 490fb113
+       CMPXCHGQ R11, (R11)                     // 4d0fb11b
+       CMPXCHGQ DX, DX                         // 480fb1d2
+       CMPXCHGQ R11, DX                        // 4c0fb1da
+       CMPXCHGQ DX, R11                        // 490fb1d3
+       CMPXCHGQ R11, R11                       // 4d0fb1db
+       CMPXCHGB DL, (BX)                       // 0fb013
+       CMPXCHGB R11, (BX)                      // 440fb01b
+       CMPXCHGB DL, (R11)                      // 410fb013
+       CMPXCHGB R11, (R11)                     // 450fb01b
+       CMPXCHGB DL, DL                         // 0fb0d2
+       CMPXCHGB R11, DL                        // 440fb0da
+       CMPXCHGB DL, R11                        // 410fb0d3
+       CMPXCHGB R11, R11                       // 450fb0db
+       //TODO: CMPXCHG16B (BX)                 // 480fc70b
+       //TODO: CMPXCHG16B (R11)                // 490fc70b
+       CMPXCHG8B (BX)                          // 0fc70b
+       CMPXCHG8B (R11)                         // 410fc70b
+       COMISD (BX), X2                         // 660f2f13
+       COMISD (R11), X2                        // 66410f2f13
+       COMISD X2, X2                           // 660f2fd2
+       COMISD X11, X2                          // 66410f2fd3
+       COMISD (BX), X11                        // 66440f2f1b
+       COMISD (R11), X11                       // 66450f2f1b
+       COMISD X2, X11                          // 66440f2fda
+       COMISD X11, X11                         // 66450f2fdb
+       COMISS (BX), X2                         // 0f2f13
+       COMISS (R11), X2                        // 410f2f13
+       COMISS X2, X2                           // 0f2fd2
+       COMISS X11, X2                          // 410f2fd3
+       COMISS (BX), X11                        // 440f2f1b
+       COMISS (R11), X11                       // 450f2f1b
+       COMISS X2, X11                          // 440f2fda
+       COMISS X11, X11                         // 450f2fdb
+       CPUID                                   // 0fa2
+       CQO                                     // 4899
+       //TODO: CRC32W (BX), DX                 // 66f20f38f113
+       //TODO: CRC32W (R11), DX                // 66f2410f38f113
+       //TODO: CRC32W DX, DX                   // 66f20f38f1d2
+       //TODO: CRC32W R11, DX                  // 66f2410f38f1d3
+       //TODO: CRC32W (BX), R11                // 66f2440f38f11b
+       //TODO: CRC32W (R11), R11               // 66f2450f38f11b
+       //TODO: CRC32W DX, R11                  // 66f2440f38f1da
+       //TODO: CRC32W R11, R11                 // 66f2450f38f1db
+       //TODO: CRC32L (BX), DX                 // f20f38f113
+       //TODO: CRC32L (R11), DX                // f2410f38f113
+       //TODO: CRC32L DX, DX                   // f20f38f1d2
+       //TODO: CRC32L R11, DX                  // f2410f38f1d3
+       //TODO: CRC32L (BX), R11                // f2440f38f11b
+       //TODO: CRC32L (R11), R11               // f2450f38f11b
+       //TODO: CRC32L DX, R11                  // f2440f38f1da
+       //TODO: CRC32L R11, R11                 // f2450f38f1db
+       //TODO: CRC32B (BX), DX                 // f20f38f013 or f2480f38f013
+       //TODO: CRC32B (R11), DX                // f2410f38f013 or f2490f38f013
+       //TODO: CRC32B DL, DX                   // f20f38f0d2 or f2480f38f0d2
+       //TODO: CRC32B R11, DX                  // f2410f38f0d3 or f2490f38f0d3
+       //TODO: CRC32B (BX), R11                // f2440f38f01b or f24c0f38f01b
+       //TODO: CRC32B (R11), R11               // f2450f38f01b or f24d0f38f01b
+       //TODO: CRC32B DL, R11                  // f2440f38f0da or f24c0f38f0da
+       //TODO: CRC32B R11, R11                 // f2450f38f0db or f24d0f38f0db
+       CRC32Q (BX), DX                         // f2480f38f113
+       CRC32Q (R11), DX                        // f2490f38f113
+       CRC32Q DX, DX                           // f2480f38f1d2
+       CRC32Q R11, DX                          // f2490f38f1d3
+       CRC32Q (BX), R11                        // f24c0f38f11b
+       CRC32Q (R11), R11                       // f24d0f38f11b
+       CRC32Q DX, R11                          // f24c0f38f1da
+       CRC32Q R11, R11                         // f24d0f38f1db
+       CVTPL2PD (BX), X2                       // f30fe613
+       CVTPL2PD (R11), X2                      // f3410fe613
+       CVTPL2PD X2, X2                         // f30fe6d2
+       CVTPL2PD X11, X2                        // f3410fe6d3
+       CVTPL2PD (BX), X11                      // f3440fe61b
+       CVTPL2PD (R11), X11                     // f3450fe61b
+       CVTPL2PD X2, X11                        // f3440fe6da
+       CVTPL2PD X11, X11                       // f3450fe6db
+       CVTPL2PS (BX), X2                       // 0f5b13
+       CVTPL2PS (R11), X2                      // 410f5b13
+       CVTPL2PS X2, X2                         // 0f5bd2
+       CVTPL2PS X11, X2                        // 410f5bd3
+       CVTPL2PS (BX), X11                      // 440f5b1b
+       CVTPL2PS (R11), X11                     // 450f5b1b
+       CVTPL2PS X2, X11                        // 440f5bda
+       CVTPL2PS X11, X11                       // 450f5bdb
+       CVTPD2PL (BX), X2                       // f20fe613
+       CVTPD2PL (R11), X2                      // f2410fe613
+       CVTPD2PL X2, X2                         // f20fe6d2
+       CVTPD2PL X11, X2                        // f2410fe6d3
+       CVTPD2PL (BX), X11                      // f2440fe61b
+       CVTPD2PL (R11), X11                     // f2450fe61b
+       CVTPD2PL X2, X11                        // f2440fe6da
+       CVTPD2PL X11, X11                       // f2450fe6db
+       //TODO: CVTPD2PI (BX), M2               // 660f2d13
+       //TODO: CVTPD2PI (R11), M2              // 66410f2d13
+       //TODO: CVTPD2PI X2, M2                 // 660f2dd2
+       //TODO: CVTPD2PI X11, M2                // 66410f2dd3
+       //TODO: CVTPD2PI (BX), M3               // 660f2d1b
+       //TODO: CVTPD2PI (R11), M3              // 66410f2d1b
+       //TODO: CVTPD2PI X2, M3                 // 660f2dda
+       //TODO: CVTPD2PI X11, M3                // 66410f2ddb
+       CVTPD2PS (BX), X2                       // 660f5a13
+       CVTPD2PS (R11), X2                      // 66410f5a13
+       CVTPD2PS X2, X2                         // 660f5ad2
+       CVTPD2PS X11, X2                        // 66410f5ad3
+       CVTPD2PS (BX), X11                      // 66440f5a1b
+       CVTPD2PS (R11), X11                     // 66450f5a1b
+       CVTPD2PS X2, X11                        // 66440f5ada
+       CVTPD2PS X11, X11                       // 66450f5adb
+       //TODO: CVTPI2PD (BX), X2               // 660f2a13
+       //TODO: CVTPI2PD (R11), X2              // 66410f2a13
+       //TODO: CVTPI2PD M2, X2                 // 660f2ad2
+       //TODO: CVTPI2PD M3, X2                 // 660f2ad3
+       //TODO: CVTPI2PD (BX), X11              // 66440f2a1b
+       //TODO: CVTPI2PD (R11), X11             // 66450f2a1b
+       //TODO: CVTPI2PD M2, X11                // 66440f2ada
+       //TODO: CVTPI2PD M3, X11                // 66440f2adb
+       //TODO: CVTPI2PS (BX), X2               // 0f2a13
+       //TODO: CVTPI2PS (R11), X2              // 410f2a13
+       //TODO: CVTPI2PS M2, X2                 // 0f2ad2
+       //TODO: CVTPI2PS M3, X2                 // 0f2ad3
+       //TODO: CVTPI2PS (BX), X11              // 440f2a1b
+       //TODO: CVTPI2PS (R11), X11             // 450f2a1b
+       //TODO: CVTPI2PS M2, X11                // 440f2ada
+       //TODO: CVTPI2PS M3, X11                // 440f2adb
+       CVTPS2PL (BX), X2                       // 660f5b13
+       CVTPS2PL (R11), X2                      // 66410f5b13
+       CVTPS2PL X2, X2                         // 660f5bd2
+       CVTPS2PL X11, X2                        // 66410f5bd3
+       CVTPS2PL (BX), X11                      // 66440f5b1b
+       CVTPS2PL (R11), X11                     // 66450f5b1b
+       CVTPS2PL X2, X11                        // 66440f5bda
+       CVTPS2PL X11, X11                       // 66450f5bdb
+       CVTPS2PD (BX), X2                       // 0f5a13
+       CVTPS2PD (R11), X2                      // 410f5a13
+       CVTPS2PD X2, X2                         // 0f5ad2
+       CVTPS2PD X11, X2                        // 410f5ad3
+       CVTPS2PD (BX), X11                      // 440f5a1b
+       CVTPS2PD (R11), X11                     // 450f5a1b
+       CVTPS2PD X2, X11                        // 440f5ada
+       CVTPS2PD X11, X11                       // 450f5adb
+       //TODO: CVTPS2PI (BX), M2               // 0f2d13
+       //TODO: CVTPS2PI (R11), M2              // 410f2d13
+       //TODO: CVTPS2PI X2, M2                 // 0f2dd2
+       //TODO: CVTPS2PI X11, M2                // 410f2dd3
+       //TODO: CVTPS2PI (BX), M3               // 0f2d1b
+       //TODO: CVTPS2PI (R11), M3              // 410f2d1b
+       //TODO: CVTPS2PI X2, M3                 // 0f2dda
+       //TODO: CVTPS2PI X11, M3                // 410f2ddb
+       CVTSD2SL (BX), DX                       // f20f2d13 or f2480f2d13
+       CVTSD2SL (R11), DX                      // f2410f2d13 or f2490f2d13
+       CVTSD2SL X2, DX                         // f20f2dd2 or f2480f2dd2
+       CVTSD2SL X11, DX                        // f2410f2dd3 or f2490f2dd3
+       CVTSD2SL (BX), R11                      // f2440f2d1b or f24c0f2d1b
+       CVTSD2SL (R11), R11                     // f2450f2d1b or f24d0f2d1b
+       CVTSD2SL X2, R11                        // f2440f2dda or f24c0f2dda
+       CVTSD2SL X11, R11                       // f2450f2ddb or f24d0f2ddb
+       CVTSD2SS (BX), X2                       // f20f5a13
+       CVTSD2SS (R11), X2                      // f2410f5a13
+       CVTSD2SS X2, X2                         // f20f5ad2
+       CVTSD2SS X11, X2                        // f2410f5ad3
+       CVTSD2SS (BX), X11                      // f2440f5a1b
+       CVTSD2SS (R11), X11                     // f2450f5a1b
+       CVTSD2SS X2, X11                        // f2440f5ada
+       CVTSD2SS X11, X11                       // f2450f5adb
+       CVTSL2SD (BX), X2                       // f20f2a13
+       CVTSL2SD (R11), X2                      // f2410f2a13
+       CVTSL2SD DX, X2                         // f20f2ad2
+       CVTSL2SD R11, X2                        // f2410f2ad3
+       CVTSL2SD (BX), X11                      // f2440f2a1b
+       CVTSL2SD (R11), X11                     // f2450f2a1b
+       CVTSL2SD DX, X11                        // f2440f2ada
+       CVTSL2SD R11, X11                       // f2450f2adb
+       CVTSQ2SD (BX), X2                       // f2480f2a13
+       CVTSQ2SD (R11), X2                      // f2490f2a13
+       CVTSQ2SD DX, X2                         // f2480f2ad2
+       CVTSQ2SD R11, X2                        // f2490f2ad3
+       CVTSQ2SD (BX), X11                      // f24c0f2a1b
+       CVTSQ2SD (R11), X11                     // f24d0f2a1b
+       CVTSQ2SD DX, X11                        // f24c0f2ada
+       CVTSQ2SD R11, X11                       // f24d0f2adb
+       CVTSL2SS (BX), X2                       // f30f2a13
+       CVTSL2SS (R11), X2                      // f3410f2a13
+       CVTSL2SS DX, X2                         // f30f2ad2
+       CVTSL2SS R11, X2                        // f3410f2ad3
+       CVTSL2SS (BX), X11                      // f3440f2a1b
+       CVTSL2SS (R11), X11                     // f3450f2a1b
+       CVTSL2SS DX, X11                        // f3440f2ada
+       CVTSL2SS R11, X11                       // f3450f2adb
+       CVTSQ2SS (BX), X2                       // f3480f2a13
+       CVTSQ2SS (R11), X2                      // f3490f2a13
+       CVTSQ2SS DX, X2                         // f3480f2ad2
+       CVTSQ2SS R11, X2                        // f3490f2ad3
+       CVTSQ2SS (BX), X11                      // f34c0f2a1b
+       CVTSQ2SS (R11), X11                     // f34d0f2a1b
+       CVTSQ2SS DX, X11                        // f34c0f2ada
+       CVTSQ2SS R11, X11                       // f34d0f2adb
+       CVTSS2SD (BX), X2                       // f30f5a13
+       CVTSS2SD (R11), X2                      // f3410f5a13
+       CVTSS2SD X2, X2                         // f30f5ad2
+       CVTSS2SD X11, X2                        // f3410f5ad3
+       CVTSS2SD (BX), X11                      // f3440f5a1b
+       CVTSS2SD (R11), X11                     // f3450f5a1b
+       CVTSS2SD X2, X11                        // f3440f5ada
+       CVTSS2SD X11, X11                       // f3450f5adb
+       CVTSS2SL (BX), DX                       // f30f2d13 or f3480f2d13
+       CVTSS2SL (R11), DX                      // f3410f2d13 or f3490f2d13
+       CVTSS2SL X2, DX                         // f30f2dd2 or f3480f2dd2
+       CVTSS2SL X11, DX                        // f3410f2dd3 or f3490f2dd3
+       CVTSS2SL (BX), R11                      // f3440f2d1b or f34c0f2d1b
+       CVTSS2SL (R11), R11                     // f3450f2d1b or f34d0f2d1b
+       CVTSS2SL X2, R11                        // f3440f2dda or f34c0f2dda
+       CVTSS2SL X11, R11                       // f3450f2ddb or f34d0f2ddb
+       CVTTPD2PL (BX), X2                      // 660fe613
+       CVTTPD2PL (R11), X2                     // 66410fe613
+       CVTTPD2PL X2, X2                        // 660fe6d2
+       CVTTPD2PL X11, X2                       // 66410fe6d3
+       CVTTPD2PL (BX), X11                     // 66440fe61b
+       CVTTPD2PL (R11), X11                    // 66450fe61b
+       CVTTPD2PL X2, X11                       // 66440fe6da
+       CVTTPD2PL X11, X11                      // 66450fe6db
+       //TODO: CVTTPD2PI (BX), M2              // 660f2c13
+       //TODO: CVTTPD2PI (R11), M2             // 66410f2c13
+       //TODO: CVTTPD2PI X2, M2                // 660f2cd2
+       //TODO: CVTTPD2PI X11, M2               // 66410f2cd3
+       //TODO: CVTTPD2PI (BX), M3              // 660f2c1b
+       //TODO: CVTTPD2PI (R11), M3             // 66410f2c1b
+       //TODO: CVTTPD2PI X2, M3                // 660f2cda
+       //TODO: CVTTPD2PI X11, M3               // 66410f2cdb
+       CVTTPS2PL (BX), X2                      // f30f5b13
+       CVTTPS2PL (R11), X2                     // f3410f5b13
+       CVTTPS2PL X2, X2                        // f30f5bd2
+       CVTTPS2PL X11, X2                       // f3410f5bd3
+       CVTTPS2PL (BX), X11                     // f3440f5b1b
+       CVTTPS2PL (R11), X11                    // f3450f5b1b
+       CVTTPS2PL X2, X11                       // f3440f5bda
+       CVTTPS2PL X11, X11                      // f3450f5bdb
+       //TODO: CVTTPS2PI (BX), M2              // 0f2c13
+       //TODO: CVTTPS2PI (R11), M2             // 410f2c13
+       //TODO: CVTTPS2PI X2, M2                // 0f2cd2
+       //TODO: CVTTPS2PI X11, M2               // 410f2cd3
+       //TODO: CVTTPS2PI (BX), M3              // 0f2c1b
+       //TODO: CVTTPS2PI (R11), M3             // 410f2c1b
+       //TODO: CVTTPS2PI X2, M3                // 0f2cda
+       //TODO: CVTTPS2PI X11, M3               // 410f2cdb
+       CVTTSD2SL (BX), DX                      // f20f2c13 or f2480f2c13
+       CVTTSD2SL (R11), DX                     // f2410f2c13 or f2490f2c13
+       CVTTSD2SL X2, DX                        // f20f2cd2 or f2480f2cd2
+       CVTTSD2SL X11, DX                       // f2410f2cd3 or f2490f2cd3
+       CVTTSD2SL (BX), R11                     // f2440f2c1b or f24c0f2c1b
+       CVTTSD2SL (R11), R11                    // f2450f2c1b or f24d0f2c1b
+       CVTTSD2SL X2, R11                       // f2440f2cda or f24c0f2cda
+       CVTTSD2SL X11, R11                      // f2450f2cdb or f24d0f2cdb
+       CVTTSS2SL (BX), DX                      // f30f2c13 or f3480f2c13
+       CVTTSS2SL (R11), DX                     // f3410f2c13 or f3490f2c13
+       CVTTSS2SL X2, DX                        // f30f2cd2 or f3480f2cd2
+       CVTTSS2SL X11, DX                       // f3410f2cd3 or f3490f2cd3
+       CVTTSS2SL (BX), R11                     // f3440f2c1b or f34c0f2c1b
+       CVTTSS2SL (R11), R11                    // f3450f2c1b or f34d0f2c1b
+       CVTTSS2SL X2, R11                       // f3440f2cda or f34c0f2cda
+       CVTTSS2SL X11, R11                      // f3450f2cdb or f34d0f2cdb
+       CWD                                     // 6699
+       //TODO: CWDE                            // 98
+       DECW (BX)                               // 66ff0b
+       DECW (R11)                              // 6641ff0b
+       DECW DX                                 // 66ffca
+       DECW R11                                // 6641ffcb
+       DECL (BX)                               // ff0b
+       DECL (R11)                              // 41ff0b
+       DECL DX                                 // ffca
+       DECL R11                                // 41ffcb
+       DECQ (BX)                               // 48ff0b
+       DECQ (R11)                              // 49ff0b
+       DECQ DX                                 // 48ffca
+       DECQ R11                                // 49ffcb
+       DECB (BX)                               // fe0b
+       DECB (R11)                              // 41fe0b
+       DECB DL                                 // feca
+       DECB R11                                // 41fecb
+       DIVW (BX)                               // 66f733
+       DIVW (R11)                              // 6641f733
+       DIVW DX                                 // 66f7f2
+       DIVW R11                                // 6641f7f3
+       DIVL (BX)                               // f733
+       DIVL (R11)                              // 41f733
+       DIVL DX                                 // f7f2
+       DIVL R11                                // 41f7f3
+       DIVQ (BX)                               // 48f733
+       DIVQ (R11)                              // 49f733
+       DIVQ DX                                 // 48f7f2
+       DIVQ R11                                // 49f7f3
+       DIVB (BX)                               // f633
+       DIVB (R11)                              // 41f633
+       DIVB DL                                 // f6f2
+       DIVB R11                                // 41f6f3
+       DIVPD (BX), X2                          // 660f5e13
+       DIVPD (R11), X2                         // 66410f5e13
+       DIVPD X2, X2                            // 660f5ed2
+       DIVPD X11, X2                           // 66410f5ed3
+       DIVPD (BX), X11                         // 66440f5e1b
+       DIVPD (R11), X11                        // 66450f5e1b
+       DIVPD X2, X11                           // 66440f5eda
+       DIVPD X11, X11                          // 66450f5edb
+       DIVPS (BX), X2                          // 0f5e13
+       DIVPS (R11), X2                         // 410f5e13
+       DIVPS X2, X2                            // 0f5ed2
+       DIVPS X11, X2                           // 410f5ed3
+       DIVPS (BX), X11                         // 440f5e1b
+       DIVPS (R11), X11                        // 450f5e1b
+       DIVPS X2, X11                           // 440f5eda
+       DIVPS X11, X11                          // 450f5edb
+       DIVSD (BX), X2                          // f20f5e13
+       DIVSD (R11), X2                         // f2410f5e13
+       DIVSD X2, X2                            // f20f5ed2
+       DIVSD X11, X2                           // f2410f5ed3
+       DIVSD (BX), X11                         // f2440f5e1b
+       DIVSD (R11), X11                        // f2450f5e1b
+       DIVSD X2, X11                           // f2440f5eda
+       DIVSD X11, X11                          // f2450f5edb
+       DIVSS (BX), X2                          // f30f5e13
+       DIVSS (R11), X2                         // f3410f5e13
+       DIVSS X2, X2                            // f30f5ed2
+       DIVSS X11, X2                           // f3410f5ed3
+       DIVSS (BX), X11                         // f3440f5e1b
+       DIVSS (R11), X11                        // f3450f5e1b
+       DIVSS X2, X11                           // f3440f5eda
+       DIVSS X11, X11                          // f3450f5edb
+       //TODO: DPPD $7, (BX), X2               // 660f3a411307
+       //TODO: DPPD $7, (R11), X2              // 66410f3a411307
+       //TODO: DPPD $7, X2, X2                 // 660f3a41d207
+       //TODO: DPPD $7, X11, X2                // 66410f3a41d307
+       //TODO: DPPD $7, (BX), X11              // 66440f3a411b07
+       //TODO: DPPD $7, (R11), X11             // 66450f3a411b07
+       //TODO: DPPD $7, X2, X11                // 66440f3a41da07
+       //TODO: DPPD $7, X11, X11               // 66450f3a41db07
+       //TODO: DPPS $7, (BX), X2               // 660f3a401307
+       //TODO: DPPS $7, (R11), X2              // 66410f3a401307
+       //TODO: DPPS $7, X2, X2                 // 660f3a40d207
+       //TODO: DPPS $7, X11, X2                // 66410f3a40d307
+       //TODO: DPPS $7, (BX), X11              // 66440f3a401b07
+       //TODO: DPPS $7, (R11), X11             // 66450f3a401b07
+       //TODO: DPPS $7, X2, X11                // 66440f3a40da07
+       //TODO: DPPS $7, X11, X11               // 66450f3a40db07
+       EMMS                                    // 0f77
+       //TODO: ENTERQ $0x12, $0xf123           // c823f112
+       //TODO: EXTRACTPS $7, X2, (BX)          // 660f3a171307
+       //TODO: EXTRACTPS $7, X11, (BX)         // 66440f3a171b07
+       //TODO: EXTRACTPS $7, X2, (R11)         // 66410f3a171307
+       //TODO: EXTRACTPS $7, X11, (R11)        // 66450f3a171b07
+       //TODO: EXTRACTPS $7, X2, DX            // 660f3a17d207
+       //TODO: EXTRACTPS $7, X11, DX           // 66440f3a17da07
+       //TODO: EXTRACTPS $7, X2, R11           // 66410f3a17d307
+       //TODO: EXTRACTPS $7, X11, R11          // 66450f3a17db07
+       F2XM1                                   // d9f0
+       FABS                                    // d9e1
+       FADDD F2, F0                            // d8c2
+       FADDD F3, F0                            // d8c3
+       FADDD F0, F2                            // dcc2
+       FADDD F0, F3                            // dcc3
+       FADDD (BX), F0                          // d803 or dc03
+       FADDD (R11), F0                         // 41d803 or 41dc03
+       FADDDP F0, F2                           // dec2
+       FADDDP F0, F3                           // dec3
+       //TODO: FBLD (BX)                       // df23
+       //TODO: FBLD (R11)                      // 41df23
+       //TODO: FBSTP (BX)                      // df33
+       //TODO: FBSTP (R11)                     // 41df33
+       FCHS                                    // d9e0
+       //TODO: FCMOVB F2, F0                   // dac2
+       //TODO: FCMOVB F3, F0                   // dac3
+       //TODO: FCMOVBE F2, F0                  // dad2
+       //TODO: FCMOVBE F3, F0                  // dad3
+       //TODO: FCMOVE F2, F0                   // daca
+       //TODO: FCMOVE F3, F0                   // dacb
+       //TODO: FCMOVNB F2, F0                  // dbc2
+       //TODO: FCMOVNB F3, F0                  // dbc3
+       //TODO: FCMOVNBE F2, F0                 // dbd2
+       //TODO: FCMOVNBE F3, F0                 // dbd3
+       FCMOVNE F2, F0                          // dbca
+       FCMOVNE F3, F0                          // dbcb
+       FCMOVNU F2, F0                          // dbda
+       FCMOVNU F3, F0                          // dbdb
+       //TODO: FCMOVU F2, F0                   // dada
+       //TODO: FCMOVU F3, F0                   // dadb
+       FCOMD F2, F0                            // d8d2
+       FCOMD F3, F0                            // d8d3
+       FCOMD (BX), F0                          // d813 or dc13
+       FCOMD (R11), F0                         // 41d813 or 41dc13
+       //TODO: FCOMI F2, F0                    // dbf2
+       //TODO: FCOMI F3, F0                    // dbf3
+       //TODO: FCOMIP F2, F0                   // dff2
+       //TODO: FCOMIP F3, F0                   // dff3
+       //TODO: FCOMP F2                        // d8da
+       //TODO: FCOMP F3                        // d8db
+       //TODO: FCOMFP (BX)                     // d81b
+       //TODO: FCOMFP (R11)                    // 41d81b
+       //TODO: FCOMPL (BX)                     // dc1b
+       //TODO: FCOMPL (R11)                    // 41dc1b
+       //TODO: FCOMPP                          // ded9
+       FCOS                                    // d9ff
+       FDECSTP                                 // d9f6
+       FDIVD F2, F0                            // d8f2
+       FDIVD F3, F0                            // d8f3
+       FDIVD F0, F2                            // dcfa or dcf2
+       FDIVD F0, F3                            // dcfb or dcf3
+       FDIVD (BX), F0                          // d833 or dc33
+       FDIVD (R11), F0                         // 41d833 or 41dc33
+       //TODO: FDIVRP F0, F2                   // defa
+       //TODO: FDIVRP F0, F3                   // defb
+       //TODO: FDIVR F2, F0                    // d8fa
+       //TODO: FDIVR F3, F0                    // d8fb
+       //TODO: FDIVFR (BX)                     // d83b
+       //TODO: FDIVFR (R11)                    // 41d83b
+       //TODO: FDIVRL (BX)                     // dc3b
+       //TODO: FDIVRL (R11)                    // 41dc3b
+       //TODO: FDIVP F0, F2                    // def2
+       //TODO: FDIVP F0, F3                    // def3
+       //TODO: FFREE F2                        // ddc2
+       //TODO: FFREE F3                        // ddc3
+       //TODO: FFREEP F2                       // dfc2
+       //TODO: FFREEP F3                       // dfc3
+       //TODO: FIADD (BX)                      // de03
+       //TODO: FIADD (R11)                     // 41de03
+       //TODO: FIADDL (BX)                     // da03
+       //TODO: FIADDL (R11)                    // 41da03
+       //TODO: FICOM (BX)                      // de13
+       //TODO: FICOM (R11)                     // 41de13
+       //TODO: FICOML (BX)                     // da13
+       //TODO: FICOML (R11)                    // 41da13
+       //TODO: FICOMP (BX)                     // de1b
+       //TODO: FICOMP (R11)                    // 41de1b
+       //TODO: FICOMPL (BX)                    // da1b
+       //TODO: FICOMPL (R11)                   // 41da1b
+       //TODO: FIDIV (BX)                      // de33
+       //TODO: FIDIV (R11)                     // 41de33
+       //TODO: FIDIVL (BX)                     // da33
+       //TODO: FIDIVL (R11)                    // 41da33
+       //TODO: FIDIVR (BX)                     // de3b
+       //TODO: FIDIVR (R11)                    // 41de3b
+       //TODO: FIDIVRL (BX)                    // da3b
+       //TODO: FIDIVRL (R11)                   // 41da3b
+       //TODO: FILD (BX)                       // df03
+       //TODO: FILD (R11)                      // 41df03
+       //TODO: FILDL (BX)                      // db03
+       //TODO: FILDL (R11)                     // 41db03
+       //TODO: FILDLL (BX)                     // df2b
+       //TODO: FILDLL (R11)                    // 41df2b
+       //TODO: FIMUL (BX)                      // de0b
+       //TODO: FIMUL (R11)                     // 41de0b
+       //TODO: FIMULL (BX)                     // da0b
+       //TODO: FIMULL (R11)                    // 41da0b
+       FINCSTP                                 // d9f7
+       //TODO: FIST (BX)                       // df13
+       //TODO: FIST (R11)                      // 41df13
+       //TODO: FISTL (BX)                      // db13
+       //TODO: FISTL (R11)                     // 41db13
+       //TODO: FISTP (BX)                      // df1b
+       //TODO: FISTP (R11)                     // 41df1b
+       //TODO: FISTPL (BX)                     // db1b
+       //TODO: FISTPL (R11)                    // 41db1b
+       //TODO: FISTPLL (BX)                    // df3b
+       //TODO: FISTPLL (R11)                   // 41df3b
+       //TODO: FISTTP (BX)                     // df0b
+       //TODO: FISTTP (R11)                    // 41df0b
+       //TODO: FISTTPL (BX)                    // db0b
+       //TODO: FISTTPL (R11)                   // 41db0b
+       //TODO: FISTTPLL (BX)                   // dd0b
+       //TODO: FISTTPLL (R11)                  // 41dd0b
+       //TODO: FISUB (BX)                      // de23
+       //TODO: FISUB (R11)                     // 41de23
+       //TODO: FISUBL (BX)                     // da23
+       //TODO: FISUBL (R11)                    // 41da23
+       //TODO: FISUBR (BX)                     // de2b
+       //TODO: FISUBR (R11)                    // 41de2b
+       //TODO: FISUBRL (BX)                    // da2b
+       //TODO: FISUBRL (R11)                   // 41da2b
+       //TODO: FLD F2                          // d9c2
+       //TODO: FLD F3                          // d9c3
+       //TODO: FLDS (BX)                       // d903
+       //TODO: FLDS (R11)                      // 41d903
+       //TODO: FLDL (BX)                       // dd03
+       //TODO: FLDL (R11)                      // 41dd03
+       //TODO: FLDT (BX)                       // db2b
+       //TODO: FLDT (R11)                      // 41db2b
+       FLD1                                    // d9e8
+       FLDCW (BX)                              // d92b
+       FLDCW (R11)                             // 41d92b
+       //TODO: FLDENVL (BX)                    // d923
+       //TODO: FLDENVL (R11)                   // 41d923
+       FLDL2E                                  // d9ea
+       FLDL2T                                  // d9e9
+       FLDLG2                                  // d9ec
+       FLDPI                                   // d9eb
+       //TODO: FMUL F2, F0                     // d8ca
+       //TODO: FMUL F3, F0                     // d8cb
+       //TODO: FMUL F0, F2                     // dcca
+       //TODO: FMUL F0, F3                     // dccb
+       //TODO: FMULS (BX)                      // d80b
+       //TODO: FMULS (R11)                     // 41d80b
+       //TODO: FMULL (BX)                      // dc0b
+       //TODO: FMULL (R11)                     // 41dc0b
+       //TODO: FMULP F0, F2                    // deca
+       //TODO: FMULP F0, F3                    // decb
+       //TODO: FNCLEX                          // dbe2
+       //TODO: FNINIT                          // dbe3
+       FNOP                                    // d9d0
+       //TODO: FNSAVEL (BX)                    // dd33
+       //TODO: FNSAVEL (R11)                   // 41dd33
+       //TODO: FNSTCW (BX)                     // d93b
+       //TODO: FNSTCW (R11)                    // 41d93b
+       //TODO: FNSTENVL (BX)                   // d933
+       //TODO: FNSTENVL (R11)                  // 41d933
+       //TODO: FNSTSW AX                       // dfe0
+       //TODO: FNSTSW (BX)                     // dd3b
+       //TODO: FNSTSW (R11)                    // 41dd3b
+       FPATAN                                  // d9f3
+       FPREM                                   // d9f8
+       FPREM1                                  // d9f5
+       FPTAN                                   // d9f2
+       FRNDINT                                 // d9fc
+       //TODO: FRSTORL (BX)                    // dd23
+       //TODO: FRSTORL (R11)                   // 41dd23
+       FSCALE                                  // d9fd
+       FSIN                                    // d9fe
+       FSINCOS                                 // d9fb
+       FSQRT                                   // d9fa
+       //TODO: FST F2                          // ddd2
+       //TODO: FST F3                          // ddd3
+       //TODO: FSTS (BX)                       // d913
+       //TODO: FSTS (R11)                      // 41d913
+       //TODO: FSTL (BX)                       // dd13
+       //TODO: FSTL (R11)                      // 41dd13
+       //TODO: FSTP F2                         // ddda
+       //TODO: FSTP F3                         // dddb
+       //TODO: FSTPS (BX)                      // d91b
+       //TODO: FSTPS (R11)                     // 41d91b
+       //TODO: FSTPL (BX)                      // dd1b
+       //TODO: FSTPL (R11)                     // 41dd1b
+       //TODO: FSTPT (BX)                      // db3b
+       //TODO: FSTPT (R11)                     // 41db3b
+       //TODO: FSUB F2, F0                     // d8e2
+       //TODO: FSUB F3, F0                     // d8e3
+       //TODO: FSUBR F0, F2                    // dcea
+       //TODO: FSUBR F0, F3                    // dceb
+       //TODO: FSUBS (BX)                      // d823
+       //TODO: FSUBS (R11)                     // 41d823
+       //TODO: FSUBL (BX)                      // dc23
+       //TODO: FSUBL (R11)                     // 41dc23
+       //TODO: FSUBRP F0, F2                   // deea
+       //TODO: FSUBRP F0, F3                   // deeb
+       //TODO: FSUBR F2, F0                    // d8ea
+       //TODO: FSUBR F3, F0                    // d8eb
+       //TODO: FSUB F0, F2                     // dce2
+       //TODO: FSUB F0, F3                     // dce3
+       //TODO: FSUBRS (BX)                     // d82b
+       //TODO: FSUBRS (R11)                    // 41d82b
+       //TODO: FSUBRL (BX)                     // dc2b
+       //TODO: FSUBRL (R11)                    // 41dc2b
+       //TODO: FSUBP F0, F2                    // dee2
+       //TODO: FSUBP F0, F3                    // dee3
+       FTST                                    // d9e4
+       //TODO: FUCOM F2                        // dde2
+       //TODO: FUCOM F3                        // dde3
+       //TODO: FUCOMI F2, F0                   // dbea
+       //TODO: FUCOMI F3, F0                   // dbeb
+       //TODO: FUCOMIP F2, F0                  // dfea
+       //TODO: FUCOMIP F3, F0                  // dfeb
+       //TODO: FUCOMP F2                       // ddea
+       //TODO: FUCOMP F3                       // ddeb
+       //TODO: FUCOMPP                         // dae9
+       //TODO: FWAIT                           // 9b
+       FXAM                                    // d9e5
+       //TODO: FXCH F2                         // d9ca
+       //TODO: FXCH F3                         // d9cb
+       FXRSTOR (BX)                            // 0fae0b
+       FXRSTOR (R11)                           // 410fae0b
+       FXRSTOR64 (BX)                          // 480fae0b
+       FXRSTOR64 (R11)                         // 490fae0b
+       FXSAVE (BX)                             // 0fae03
+       FXSAVE (R11)                            // 410fae03
+       FXSAVE64 (BX)                           // 480fae03
+       FXSAVE64 (R11)                          // 490fae03
+       FXTRACT                                 // d9f4
+       FYL2X                                   // d9f1
+       FYL2XP1                                 // d9f9
+       HADDPD (BX), X2                         // 660f7c13
+       HADDPD (R11), X2                        // 66410f7c13
+       HADDPD X2, X2                           // 660f7cd2
+       HADDPD X11, X2                          // 66410f7cd3
+       HADDPD (BX), X11                        // 66440f7c1b
+       HADDPD (R11), X11                       // 66450f7c1b
+       HADDPD X2, X11                          // 66440f7cda
+       HADDPD X11, X11                         // 66450f7cdb
+       HADDPS (BX), X2                         // f20f7c13
+       HADDPS (R11), X2                        // f2410f7c13
+       HADDPS X2, X2                           // f20f7cd2
+       HADDPS X11, X2                          // f2410f7cd3
+       HADDPS (BX), X11                        // f2440f7c1b
+       HADDPS (R11), X11                       // f2450f7c1b
+       HADDPS X2, X11                          // f2440f7cda
+       HADDPS X11, X11                         // f2450f7cdb
+       HLT                                     // f4
+       HSUBPD (BX), X2                         // 660f7d13
+       HSUBPD (R11), X2                        // 66410f7d13
+       HSUBPD X2, X2                           // 660f7dd2
+       HSUBPD X11, X2                          // 66410f7dd3
+       HSUBPD (BX), X11                        // 66440f7d1b
+       HSUBPD (R11), X11                       // 66450f7d1b
+       HSUBPD X2, X11                          // 66440f7dda
+       HSUBPD X11, X11                         // 66450f7ddb
+       HSUBPS (BX), X2                         // f20f7d13
+       HSUBPS (R11), X2                        // f2410f7d13
+       HSUBPS X2, X2                           // f20f7dd2
+       HSUBPS X11, X2                          // f2410f7dd3
+       HSUBPS (BX), X11                        // f2440f7d1b
+       HSUBPS (R11), X11                       // f2450f7d1b
+       HSUBPS X2, X11                          // f2440f7dda
+       HSUBPS X11, X11                         // f2450f7ddb
+       //TODO: ICEBP                           // f1
+       IDIVW (BX)                              // 66f73b
+       IDIVW (R11)                             // 6641f73b
+       IDIVW DX                                // 66f7fa
+       IDIVW R11                               // 6641f7fb
+       IDIVL (BX)                              // f73b
+       IDIVL (R11)                             // 41f73b
+       IDIVL DX                                // f7fa
+       IDIVL R11                               // 41f7fb
+       IDIVQ (BX)                              // 48f73b
+       IDIVQ (R11)                             // 49f73b
+       IDIVQ DX                                // 48f7fa
+       IDIVQ R11                               // 49f7fb
+       IDIVB (BX)                              // f63b
+       IDIVB (R11)                             // 41f63b
+       IDIVB DL                                // f6fa
+       IDIVB R11                               // 41f6fb
+       IMULW (BX)                              // 66f72b
+       IMULW (R11)                             // 6641f72b
+       IMULW DX                                // 66f7ea
+       IMULW R11                               // 6641f7eb
+       IMULL (BX)                              // f72b
+       IMULL (R11)                             // 41f72b
+       IMULL DX                                // f7ea
+       IMULL R11                               // 41f7eb
+       IMULQ (BX)                              // 48f72b
+       IMULQ (R11)                             // 49f72b
+       IMULQ DX                                // 48f7ea
+       IMULQ R11                               // 49f7eb
+       IMULB (BX)                              // f62b
+       IMULB (R11)                             // 41f62b
+       IMULB DL                                // f6ea
+       IMULB R11                               // 41f6eb
+       IMULW (BX), DX                          // 660faf13
+       IMULW (R11), DX                         // 66410faf13
+       IMULW DX, DX                            // 660fafd2
+       IMULW R11, DX                           // 66410fafd3
+       IMULW (BX), R11                         // 66440faf1b
+       IMULW (R11), R11                        // 66450faf1b
+       IMULW DX, R11                           // 66440fafda
+       IMULW R11, R11                          // 66450fafdb
+       //TODO: IMULW $0xf123, (BX), DX         // 66691323f1
+       //TODO: IMULW $0xf123, (R11), DX        // 6641691323f1
+       //TODO: IMULW $0xf123, DX, DX           // 6669d223f1
+       //TODO: IMULW $0xf123, R11, DX          // 664169d323f1
+       //TODO: IMULW $0xf123, (BX), R11        // 6644691b23f1
+       //TODO: IMULW $0xf123, (R11), R11       // 6645691b23f1
+       //TODO: IMULW $0xf123, DX, R11          // 664469da23f1
+       //TODO: IMULW $0xf123, R11, R11         // 664569db23f1
+       //TODO: IMULW $7, (BX), DX              // 666b1307
+       //TODO: IMULW $7, (R11), DX             // 66416b1307
+       //TODO: IMULW $7, DX, DX                // 666bd207
+       //TODO: IMULW $7, R11, DX               // 66416bd307
+       //TODO: IMULW $7, (BX), R11             // 66446b1b07
+       //TODO: IMULW $7, (R11), R11            // 66456b1b07
+       //TODO: IMULW $7, DX, R11               // 66446bda07
+       //TODO: IMULW $7, R11, R11              // 66456bdb07
+       IMULL (BX), DX                          // 0faf13
+       IMULL (R11), DX                         // 410faf13
+       IMULL DX, DX                            // 0fafd2
+       IMULL R11, DX                           // 410fafd3
+       IMULL (BX), R11                         // 440faf1b
+       IMULL (R11), R11                        // 450faf1b
+       IMULL DX, R11                           // 440fafda
+       IMULL R11, R11                          // 450fafdb
+       //TODO: IMULL $0xf1234567, (BX), DX     // 6913674523f1
+       //TODO: IMULL $0xf1234567, (R11), DX    // 416913674523f1
+       //TODO: IMULL $0xf1234567, DX, DX       // 69d2674523f1
+       //TODO: IMULL $0xf1234567, R11, DX      // 4169d3674523f1
+       //TODO: IMULL $0xf1234567, (BX), R11    // 44691b674523f1
+       //TODO: IMULL $0xf1234567, (R11), R11   // 45691b674523f1
+       //TODO: IMULL $0xf1234567, DX, R11      // 4469da674523f1
+       //TODO: IMULL $0xf1234567, R11, R11     // 4569db674523f1
+       //TODO: IMULL $7, (BX), DX              // 6b1307
+       //TODO: IMULL $7, (R11), DX             // 416b1307
+       //TODO: IMULL $7, DX, DX                // 6bd207
+       //TODO: IMULL $7, R11, DX               // 416bd307
+       //TODO: IMULL $7, (BX), R11             // 446b1b07
+       //TODO: IMULL $7, (R11), R11            // 456b1b07
+       //TODO: IMULL $7, DX, R11               // 446bda07
+       //TODO: IMULL $7, R11, R11              // 456bdb07
+       IMULQ (BX), DX                          // 480faf13
+       IMULQ (R11), DX                         // 490faf13
+       IMULQ DX, DX                            // 480fafd2
+       IMULQ R11, DX                           // 490fafd3
+       IMULQ (BX), R11                         // 4c0faf1b
+       IMULQ (R11), R11                        // 4d0faf1b
+       IMULQ DX, R11                           // 4c0fafda
+       IMULQ R11, R11                          // 4d0fafdb
+       //TODO: IMULQ $0xfffffffff1234567, (BX), DX // 486913674523f1
+       //TODO: IMULQ $0xfffffffff1234567, (R11), DX // 496913674523f1
+       //TODO: IMULQ $0xfffffffff1234567, DX, DX // 4869d2674523f1
+       //TODO: IMULQ $0xfffffffff1234567, R11, DX // 4969d3674523f1
+       //TODO: IMULQ $0xfffffffff1234567, (BX), R11 // 4c691b674523f1
+       //TODO: IMULQ $0xfffffffff1234567, (R11), R11 // 4d691b674523f1
+       //TODO: IMULQ $0xfffffffff1234567, DX, R11 // 4c69da674523f1
+       //TODO: IMULQ $0xfffffffff1234567, R11, R11 // 4d69db674523f1
+       IMUL3Q $7, (BX), DX                     // 486b1307
+       IMUL3Q $7, (R11), DX                    // 496b1307
+       IMUL3Q $7, DX, DX                       // 486bd207
+       IMUL3Q $7, R11, DX                      // 496bd307
+       IMUL3Q $7, (BX), R11                    // 4c6b1b07
+       IMUL3Q $7, (R11), R11                   // 4d6b1b07
+       IMUL3Q $7, DX, R11                      // 4c6bda07
+       IMUL3Q $7, R11, R11                     // 4d6bdb07
+       //TODO: INB DX, AL                      // ec
+       //TODO: INB $7, AL                      // e407
+       //TODO: INW DX, AX                      // 66ed
+       //TODO: INW $7, AX                      // 66e507
+       //TODO: INL DX, AX                      // ed
+       //TODO: INL $7, AX                      // e507
+       INCW (BX)                               // 66ff03
+       INCW (R11)                              // 6641ff03
+       INCW DX                                 // 66ffc2
+       INCW R11                                // 6641ffc3
+       INCL (BX)                               // ff03
+       INCL (R11)                              // 41ff03
+       INCL DX                                 // ffc2
+       INCL R11                                // 41ffc3
+       INCQ (BX)                               // 48ff03
+       INCQ (R11)                              // 49ff03
+       INCQ DX                                 // 48ffc2
+       INCQ R11                                // 49ffc3
+       INCB (BX)                               // fe03
+       INCB (R11)                              // 41fe03
+       INCB DL                                 // fec2
+       INCB R11                                // 41fec3
+       INSB                                    // 6c
+       INSL                                    // 6d
+       //TODO: INSERTPS $7, (BX), X2           // 660f3a211307
+       //TODO: INSERTPS $7, (R11), X2          // 66410f3a211307
+       //TODO: INSERTPS $7, X2, X2             // 660f3a21d207
+       //TODO: INSERTPS $7, X11, X2            // 66410f3a21d307
+       //TODO: INSERTPS $7, (BX), X11          // 66440f3a211b07
+       //TODO: INSERTPS $7, (R11), X11         // 66450f3a211b07
+       //TODO: INSERTPS $7, X2, X11            // 66440f3a21da07
+       //TODO: INSERTPS $7, X11, X11           // 66450f3a21db07
+       INSW                                    // 666d
+       //TODO: INT $3                          // cc
+       INT $7                                  // cd07
+       INVD                                    // 0f08
+       INVLPG (BX)                             // 0f013b
+       INVLPG (R11)                            // 410f013b
+       //TODO: INVPCID (BX), DX                // 660f388213
+       //TODO: INVPCID (R11), DX               // 66410f388213
+       //TODO: INVPCID (BX), R11               // 66440f38821b
+       //TODO: INVPCID (R11), R11              // 66450f38821b
+       JCS 2(PC)
+       IRETW                                   // 66cf
+       JCS 2(PC)
+       IRETL                                   // cf
+       JCS 2(PC)
+       IRETQ                                   // 48cf
+       //TODO: JA .+$0x11223344                // 480f8744332211 or 0f8744332211
+       //TODO: JA .+$0x11                      // 7711
+       //TODO: JAE .+$0x11223344               // 0f8344332211 or 480f8344332211
+       //TODO: JAE .+$0x11                     // 7311
+       //TODO: JB .+$0x11223344                // 480f8244332211 or 0f8244332211
+       //TODO: JB .+$0x11                      // 7211
+       //TODO: JBE .+$0x11223344               // 0f8644332211 or 480f8644332211
+       //TODO: JBE .+$0x11                     // 7611
+       //TODO: JE .+$0x11223344                // 480f8444332211 or 0f8444332211
+       //TODO: JE .+$0x11                      // 7411
+       //TODO: JECXZ .+$0x11                   // e311
+       //TODO: JG .+$0x11223344                // 0f8f44332211 or 480f8f44332211
+       //TODO: JG .+$0x11                      // 7f11
+       //TODO: JGE .+$0x11223344               // 480f8d44332211 or 0f8d44332211
+       //TODO: JGE .+$0x11                     // 7d11
+       //TODO: JL .+$0x11223344                // 0f8c44332211 or 480f8c44332211
+       //TODO: JL .+$0x11                      // 7c11
+       //TODO: JLE .+$0x11223344               // 0f8e44332211 or 480f8e44332211
+       //TODO: JLE .+$0x11                     // 7e11
+       JCS 2(PC)
+       //TODO: JMPQ* (BX)                      // ff23
+       JCS 2(PC)
+       //TODO: JMPQ* (R11)                     // 41ff23
+       JCS 2(PC)
+       //TODO: JMPQ* DX                        // ffe2
+       JCS 2(PC)
+       //TODO: JMPQ* R11                       // 41ffe3
+       JCS 2(PC)
+       //TODO: JMP .+$0x11223344               // 48e944332211 or e944332211
+       JCS 2(PC)
+       JCS 2(PC)
+       //TODO: JMP .+$0x11                     // eb11
+       JCS 2(PC)
+       //TODO: LJMPW* (BX)                     // 66ff2b
+       JCS 2(PC)
+       //TODO: LJMPW* (R11)                    // 6641ff2b
+       JCS 2(PC)
+       //TODO: LJMPL* (BX)                     // ff2b
+       JCS 2(PC)
+       //TODO: LJMPL* (R11)                    // 41ff2b
+       JCS 2(PC)
+       //TODO: LJMPQ* (BX)                     // 48ff2b
+       JCS 2(PC)
+       //TODO: LJMPQ* (R11)                    // 49ff2b
+       //TODO: JNE .+$0x11223344               // 480f8544332211 or 0f8544332211
+       //TODO: JNE .+$0x11                     // 7511
+       //TODO: JNO .+$0x11223344               // 480f8144332211 or 0f8144332211
+       //TODO: JNO .+$0x11                     // 7111
+       //TODO: JNP .+$0x11223344               // 480f8b44332211 or 0f8b44332211
+       //TODO: JNP .+$0x11                     // 7b11
+       //TODO: JNS .+$0x11223344               // 0f8944332211 or 480f8944332211
+       //TODO: JNS .+$0x11                     // 7911
+       //TODO: JO .+$0x11223344                // 0f8044332211 or 480f8044332211
+       //TODO: JO .+$0x11                      // 7011
+       //TODO: JP .+$0x11223344                // 480f8a44332211 or 0f8a44332211
+       //TODO: JP .+$0x11                      // 7a11
+       //TODO: JRCXZ .+$0x11                   // e311
+       //TODO: JS .+$0x11223344                // 480f8844332211 or 0f8844332211
+       //TODO: JS .+$0x11                      // 7811
+       LAHF                                    // 9f
+       LARW (BX), DX                           // 660f0213
+       LARW (R11), DX                          // 66410f0213
+       LARW DX, DX                             // 660f02d2
+       LARW R11, DX                            // 66410f02d3
+       LARW (BX), R11                          // 66440f021b
+       LARW (R11), R11                         // 66450f021b
+       LARW DX, R11                            // 66440f02da
+       LARW R11, R11                           // 66450f02db
+       LARL (BX), DX                           // 0f0213
+       LARL (R11), DX                          // 410f0213
+       LARL DX, DX                             // 0f02d2
+       LARL R11, DX                            // 410f02d3
+       LARL (BX), R11                          // 440f021b
+       LARL (R11), R11                         // 450f021b
+       LARL DX, R11                            // 440f02da
+       LARL R11, R11                           // 450f02db
+       //TODO: LARQ (BX), DX                   // 480f0213
+       //TODO: LARQ (R11), DX                  // 490f0213
+       //TODO: LARQ DX, DX                     // 480f02d2
+       //TODO: LARQ R11, DX                    // 490f02d3
+       //TODO: LARQ (BX), R11                  // 4c0f021b
+       //TODO: LARQ (R11), R11                 // 4d0f021b
+       //TODO: LARQ DX, R11                    // 4c0f02da
+       //TODO: LARQ R11, R11                   // 4d0f02db
+       LDDQU (BX), X2                          // f20ff013
+       LDDQU (R11), X2                         // f2410ff013
+       LDDQU (BX), X11                         // f2440ff01b
+       LDDQU (R11), X11                        // f2450ff01b
+       LDMXCSR (BX)                            // 0fae13
+       LDMXCSR (R11)                           // 410fae13
+       LEAW (BX), DX                           // 668d13
+       LEAW (R11), DX                          // 66418d13
+       LEAW (BX), R11                          // 66448d1b
+       LEAW (R11), R11                         // 66458d1b
+       LEAL (BX), DX                           // 8d13
+       LEAL (R11), DX                          // 418d13
+       LEAL (BX), R11                          // 448d1b
+       LEAL (R11), R11                         // 458d1b
+       LEAQ (BX), DX                           // 488d13
+       LEAQ (R11), DX                          // 498d13
+       LEAQ (BX), R11                          // 4c8d1b
+       LEAQ (R11), R11                         // 4d8d1b
+       LEAVEQ                                  // 66c9 or c9
+       LFENCE                                  // 0faee8
+       //TODO: LFSW (BX), DX                   // 660fb413
+       //TODO: LFSW (R11), DX                  // 66410fb413
+       //TODO: LFSW (BX), R11                  // 66440fb41b
+       //TODO: LFSW (R11), R11                 // 66450fb41b
+       //TODO: LFSL (BX), DX                   // 0fb413
+       //TODO: LFSL (R11), DX                  // 410fb413
+       //TODO: LFSL (BX), R11                  // 440fb41b
+       //TODO: LFSL (R11), R11                 // 450fb41b
+       //TODO: LFSQ (BX), DX                   // 480fb413
+       //TODO: LFSQ (R11), DX                  // 490fb413
+       //TODO: LFSQ (BX), R11                  // 4c0fb41b
+       //TODO: LFSQ (R11), R11                 // 4d0fb41b
+       //TODO: LGDT (BX)                       // 0f0113
+       //TODO: LGDT (R11)                      // 410f0113
+       //TODO: LGSW (BX), DX                   // 660fb513
+       //TODO: LGSW (R11), DX                  // 66410fb513
+       //TODO: LGSW (BX), R11                  // 66440fb51b
+       //TODO: LGSW (R11), R11                 // 66450fb51b
+       //TODO: LGSL (BX), DX                   // 0fb513
+       //TODO: LGSL (R11), DX                  // 410fb513
+       //TODO: LGSL (BX), R11                  // 440fb51b
+       //TODO: LGSL (R11), R11                 // 450fb51b
+       //TODO: LGSQ (BX), DX                   // 480fb513
+       //TODO: LGSQ (R11), DX                  // 490fb513
+       //TODO: LGSQ (BX), R11                  // 4c0fb51b
+       //TODO: LGSQ (R11), R11                 // 4d0fb51b
+       //TODO: LIDT (BX)                       // 0f011b
+       //TODO: LIDT (R11)                      // 410f011b
+       //TODO: LLDT (BX)                       // 0f0013
+       //TODO: LLDT (R11)                      // 410f0013
+       //TODO: LLDT DX                         // 0f00d2
+       //TODO: LLDT R11                        // 410f00d3
+       //TODO: LMSW (BX)                       // 0f0133
+       //TODO: LMSW (R11)                      // 410f0133
+       //TODO: LMSW DX                         // 0f01f2
+       //TODO: LMSW R11                        // 410f01f3
+       LODSB                                   // ac
+       LODSL                                   // ad
+       LODSQ                                   // 48ad
+       LODSW                                   // 66ad
+       //TODO: LOOP .+$0x11                    // e211
+       //TODO: LOOPEQ .+$0x11                  // e111
+       //TODO: LOOPNE .+$0x11                  // e011
+       LSLW (BX), DX                           // 660f0313
+       LSLW (R11), DX                          // 66410f0313
+       LSLW DX, DX                             // 660f03d2
+       LSLW R11, DX                            // 66410f03d3
+       LSLW (BX), R11                          // 66440f031b
+       LSLW (R11), R11                         // 66450f031b
+       LSLW DX, R11                            // 66440f03da
+       LSLW R11, R11                           // 66450f03db
+       LSLL (BX), DX                           // 0f0313
+       LSLL (R11), DX                          // 410f0313
+       LSLL DX, DX                             // 0f03d2
+       LSLL R11, DX                            // 410f03d3
+       LSLL (BX), R11                          // 440f031b
+       LSLL (R11), R11                         // 450f031b
+       LSLL DX, R11                            // 440f03da
+       LSLL R11, R11                           // 450f03db
+       //TODO: LSLQ (BX), DX                   // 480f0313
+       //TODO: LSLQ (R11), DX                  // 490f0313
+       //TODO: LSLQ DX, DX                     // 480f03d2
+       //TODO: LSLQ R11, DX                    // 490f03d3
+       //TODO: LSLQ (BX), R11                  // 4c0f031b
+       //TODO: LSLQ (R11), R11                 // 4d0f031b
+       //TODO: LSLQ DX, R11                    // 4c0f03da
+       //TODO: LSLQ R11, R11                   // 4d0f03db
+       //TODO: LSSW (BX), DX                   // 660fb213
+       //TODO: LSSW (R11), DX                  // 66410fb213
+       //TODO: LSSW (BX), R11                  // 66440fb21b
+       //TODO: LSSW (R11), R11                 // 66450fb21b
+       //TODO: LSSL (BX), DX                   // 0fb213
+       //TODO: LSSL (R11), DX                  // 410fb213
+       //TODO: LSSL (BX), R11                  // 440fb21b
+       //TODO: LSSL (R11), R11                 // 450fb21b
+       //TODO: LSSQ (BX), DX                   // 480fb213
+       //TODO: LSSQ (R11), DX                  // 490fb213
+       //TODO: LSSQ (BX), R11                  // 4c0fb21b
+       //TODO: LSSQ (R11), R11                 // 4d0fb21b
+       //TODO: LTR (BX)                        // 0f001b
+       //TODO: LTR (R11)                       // 410f001b
+       //TODO: LTR DX                          // 0f00da
+       //TODO: LTR R11                         // 410f00db
+       //TODO: LZCNTW (BX), DX                 // 66f30fbd13
+       //TODO: LZCNTW (R11), DX                // 66f3410fbd13
+       //TODO: LZCNTW DX, DX                   // 66f30fbdd2
+       //TODO: LZCNTW R11, DX                  // 66f3410fbdd3
+       //TODO: LZCNTW (BX), R11                // 66f3440fbd1b
+       //TODO: LZCNTW (R11), R11               // 66f3450fbd1b
+       //TODO: LZCNTW DX, R11                  // 66f3440fbdda
+       //TODO: LZCNTW R11, R11                 // 66f3450fbddb
+       //TODO: LZCNTL (BX), DX                 // f30fbd13
+       //TODO: LZCNTL (R11), DX                // f3410fbd13
+       //TODO: LZCNTL DX, DX                   // f30fbdd2
+       //TODO: LZCNTL R11, DX                  // f3410fbdd3
+       //TODO: LZCNTL (BX), R11                // f3440fbd1b
+       //TODO: LZCNTL (R11), R11               // f3450fbd1b
+       //TODO: LZCNTL DX, R11                  // f3440fbdda
+       //TODO: LZCNTL R11, R11                 // f3450fbddb
+       //TODO: LZCNTQ (BX), DX                 // f3480fbd13
+       //TODO: LZCNTQ (R11), DX                // f3490fbd13
+       //TODO: LZCNTQ DX, DX                   // f3480fbdd2
+       //TODO: LZCNTQ R11, DX                  // f3490fbdd3
+       //TODO: LZCNTQ (BX), R11                // f34c0fbd1b
+       //TODO: LZCNTQ (R11), R11               // f34d0fbd1b
+       //TODO: LZCNTQ DX, R11                  // f34c0fbdda
+       //TODO: LZCNTQ R11, R11                 // f34d0fbddb
+       MASKMOVOU X2, X2                        // 660ff7d2
+       MASKMOVOU X11, X2                       // 66410ff7d3
+       MASKMOVOU X2, X11                       // 66440ff7da
+       MASKMOVOU X11, X11                      // 66450ff7db
+       MASKMOVQ M2, M2                         // 0ff7d2
+       MASKMOVQ M3, M2                         // 0ff7d3
+       MASKMOVQ M2, M3                         // 0ff7da
+       MASKMOVQ M3, M3                         // 0ff7db
+       MAXPD (BX), X2                          // 660f5f13
+       MAXPD (R11), X2                         // 66410f5f13
+       MAXPD X2, X2                            // 660f5fd2
+       MAXPD X11, X2                           // 66410f5fd3
+       MAXPD (BX), X11                         // 66440f5f1b
+       MAXPD (R11), X11                        // 66450f5f1b
+       MAXPD X2, X11                           // 66440f5fda
+       MAXPD X11, X11                          // 66450f5fdb
+       MAXPS (BX), X2                          // 0f5f13
+       MAXPS (R11), X2                         // 410f5f13
+       MAXPS X2, X2                            // 0f5fd2
+       MAXPS X11, X2                           // 410f5fd3
+       MAXPS (BX), X11                         // 440f5f1b
+       MAXPS (R11), X11                        // 450f5f1b
+       MAXPS X2, X11                           // 440f5fda
+       MAXPS X11, X11                          // 450f5fdb
+       MAXSD (BX), X2                          // f20f5f13
+       MAXSD (R11), X2                         // f2410f5f13
+       MAXSD X2, X2                            // f20f5fd2
+       MAXSD X11, X2                           // f2410f5fd3
+       MAXSD (BX), X11                         // f2440f5f1b
+       MAXSD (R11), X11                        // f2450f5f1b
+       MAXSD X2, X11                           // f2440f5fda
+       MAXSD X11, X11                          // f2450f5fdb
+       MAXSS (BX), X2                          // f30f5f13
+       MAXSS (R11), X2                         // f3410f5f13
+       MAXSS X2, X2                            // f30f5fd2
+       MAXSS X11, X2                           // f3410f5fd3
+       MAXSS (BX), X11                         // f3440f5f1b
+       MAXSS (R11), X11                        // f3450f5f1b
+       MAXSS X2, X11                           // f3440f5fda
+       MAXSS X11, X11                          // f3450f5fdb
+       MFENCE                                  // 0faef0
+       MINPD (BX), X2                          // 660f5d13
+       MINPD (R11), X2                         // 66410f5d13
+       MINPD X2, X2                            // 660f5dd2
+       MINPD X11, X2                           // 66410f5dd3
+       MINPD (BX), X11                         // 66440f5d1b
+       MINPD (R11), X11                        // 66450f5d1b
+       MINPD X2, X11                           // 66440f5dda
+       MINPD X11, X11                          // 66450f5ddb
+       MINPS (BX), X2                          // 0f5d13
+       MINPS (R11), X2                         // 410f5d13
+       MINPS X2, X2                            // 0f5dd2
+       MINPS X11, X2                           // 410f5dd3
+       MINPS (BX), X11                         // 440f5d1b
+       MINPS (R11), X11                        // 450f5d1b
+       MINPS X2, X11                           // 440f5dda
+       MINPS X11, X11                          // 450f5ddb
+       MINSD (BX), X2                          // f20f5d13
+       MINSD (R11), X2                         // f2410f5d13
+       MINSD X2, X2                            // f20f5dd2
+       MINSD X11, X2                           // f2410f5dd3
+       MINSD (BX), X11                         // f2440f5d1b
+       MINSD (R11), X11                        // f2450f5d1b
+       MINSD X2, X11                           // f2440f5dda
+       MINSD X11, X11                          // f2450f5ddb
+       MINSS (BX), X2                          // f30f5d13
+       MINSS (R11), X2                         // f3410f5d13
+       MINSS X2, X2                            // f30f5dd2
+       MINSS X11, X2                           // f3410f5dd3
+       MINSS (BX), X11                         // f3440f5d1b
+       MINSS (R11), X11                        // f3450f5d1b
+       MINSS X2, X11                           // f3440f5dda
+       MINSS X11, X11                          // f3450f5ddb
+       //TODO: MONITOR                         // 0f01c8
+       //TODO: MOVABSB 0x123456789abcdef1, AL  // a0f1debc9a78563412
+       //TODO: MOVW 0x123456789abcdef1, AX     // 66a1f1debc9a78563412
+       MOVQ DX, CR2                            // 0f22d2
+       MOVQ R11, CR2                           // 410f22d3
+       MOVQ DX, CR3                            // 0f22da
+       MOVQ R11, CR3                           // 410f22db
+       //TODO: MOVQ DX, DR2                    // 0f23d2
+       //TODO: MOVQ R11, DR2                   // 410f23d3
+       //TODO: MOVQ DX, DR3                    // 0f23da
+       //TODO: MOVQ R11, DR3                   // 410f23db
+       //TODO: MOVL 0x123456789abcdef1, AX     // a1f1debc9a78563412
+       //TODO: MOVQ 0x123456789abcdef1, AX     // 48a1f1debc9a78563412
+       //TODO: MOVW (BX), SS                   // 668e13 or 488e13
+       //TODO: MOVW (R11), SS                  // 66418e13 or 498e13
+       //TODO: MOVW DX, SS                     // 668ed2 or 488ed2
+       //TODO: MOVW R11, SS                    // 66418ed3 or 498ed3
+       //TODO: MOVW (BX), DS                   // 668e1b or 488e1b
+       //TODO: MOVW (R11), DS                  // 66418e1b or 498e1b
+       //TODO: MOVW DX, DS                     // 668eda or 488eda
+       //TODO: MOVW R11, DS                    // 66418edb or 498edb
+       //TODO: MOVL (BX), SS                   // 8e13
+       //TODO: MOVL (R11), SS                  // 418e13
+       //TODO: MOVL DX, SS                     // 8ed2
+       //TODO: MOVL R11, SS                    // 418ed3
+       //TODO: MOVL (BX), DS                   // 8e1b
+       //TODO: MOVL (R11), DS                  // 418e1b
+       //TODO: MOVL DX, DS                     // 8eda
+       //TODO: MOVL R11, DS                    // 418edb
+       //TODO: MOVW AX, 0x123456789abcdef1     // 66a3f1debc9a78563412
+       //TODO: MOVL AX, 0x123456789abcdef1     // a3f1debc9a78563412
+       //TODO: MOVQ AX, 0x123456789abcdef1     // 48a3f1debc9a78563412
+       //TODO: MOVABSB AL, 0x123456789abcdef1  // a2f1debc9a78563412
+       //TODO: MOVW SS, (BX)                   // 668c13 or 488c13
+       //TODO: MOVW DS, (BX)                   // 668c1b or 488c1b
+       //TODO: MOVW SS, (R11)                  // 66418c13 or 498c13
+       //TODO: MOVW DS, (R11)                  // 66418c1b or 498c1b
+       //TODO: MOVW SS, DX                     // 668cd2 or 488cd2
+       //TODO: MOVW DS, DX                     // 668cda or 488cda
+       //TODO: MOVW SS, R11                    // 66418cd3 or 498cd3
+       //TODO: MOVW DS, R11                    // 66418cdb or 498cdb
+       MOVW $61731, (BX)                       // 66c70323f1
+       MOVW $61731, (R11)                      // 6641c70323f1
+       MOVW $61731, DX                         // 66c7c223f1 or 66ba23f1
+       MOVW $61731, R11                        // 6641c7c323f1 or 6641bb23f1
+       MOVW DX, (BX)                           // 668913
+       MOVW R11, (BX)                          // 6644891b
+       MOVW DX, (R11)                          // 66418913
+       MOVW R11, (R11)                         // 6645891b
+       MOVW DX, DX                             // 6689d2 or 668bd2
+       MOVW R11, DX                            // 664489da or 66418bd3
+       MOVW DX, R11                            // 664189d3 or 66448bda
+       MOVW R11, R11                           // 664589db or 66458bdb
+       //TODO: MOVL SS, (BX)                   // 8c13
+       //TODO: MOVL DS, (BX)                   // 8c1b
+       //TODO: MOVL SS, (R11)                  // 418c13
+       //TODO: MOVL DS, (R11)                  // 418c1b
+       //TODO: MOVL SS, DX                     // 8cd2
+       //TODO: MOVL DS, DX                     // 8cda
+       //TODO: MOVL SS, R11                    // 418cd3
+       //TODO: MOVL DS, R11                    // 418cdb
+       MOVL $4045620583, (BX)                  // c703674523f1
+       MOVL $4045620583, (R11)                 // 41c703674523f1
+       MOVL $4045620583, DX                    // c7c2674523f1 or ba674523f1
+       MOVL $4045620583, R11                   // 41c7c3674523f1 or 41bb674523f1
+       MOVL DX, (BX)                           // 8913
+       MOVL R11, (BX)                          // 44891b
+       MOVL DX, (R11)                          // 418913
+       MOVL R11, (R11)                         // 45891b
+       MOVL DX, DX                             // 89d2 or 8bd2
+       MOVL R11, DX                            // 4489da or 418bd3
+       MOVL DX, R11                            // 4189d3 or 448bda
+       MOVL R11, R11                           // 4589db or 458bdb
+       MOVQ $-249346713, (BX)                  // 48c703674523f1
+       MOVQ $-249346713, (R11)                 // 49c703674523f1
+       MOVQ $-249346713, DX                    // 48c7c2674523f1
+       MOVQ $-249346713, R11                   // 49c7c3674523f1
+       MOVQ DX, (BX)                           // 488913
+       MOVQ R11, (BX)                          // 4c891b
+       MOVQ DX, (R11)                          // 498913
+       MOVQ R11, (R11)                         // 4d891b
+       MOVQ DX, DX                             // 4889d2 or 488bd2
+       MOVQ R11, DX                            // 4c89da or 498bd3
+       MOVQ DX, R11                            // 4989d3 or 4c8bda
+       MOVQ R11, R11                           // 4d89db or 4d8bdb
+       MOVB $7, (BX)                           // c60307
+       MOVB $7, (R11)                          // 41c60307
+       MOVB $7, DL                             // c6c207 or b207
+       MOVB $7, R11                            // 41c6c307 or 41b307
+       MOVB DL, (BX)                           // 8813
+       MOVB R11, (BX)                          // 44881b
+       MOVB DL, (R11)                          // 418813
+       MOVB R11, (R11)                         // 45881b
+       MOVB DL, DL                             // 88d2 or 8ad2
+       MOVB R11, DL                            // 4488da or 418ad3
+       MOVB DL, R11                            // 4188d3 or 448ada
+       MOVB R11, R11                           // 4588db or 458adb
+       MOVW (BX), DX                           // 668b13
+       MOVW (R11), DX                          // 66418b13
+       MOVW (BX), R11                          // 66448b1b
+       MOVW (R11), R11                         // 66458b1b
+       MOVL (BX), DX                           // 8b13
+       MOVL (R11), DX                          // 418b13
+       MOVL (BX), R11                          // 448b1b
+       MOVL (R11), R11                         // 458b1b
+       MOVQ (BX), DX                           // 488b13
+       MOVQ (R11), DX                          // 498b13
+       MOVQ (BX), R11                          // 4c8b1b
+       MOVQ (R11), R11                         // 4d8b1b
+       MOVQ $-1070935975390360081, DX          // 48baefcdab89674523f1
+       MOVQ $-1070935975390360081, R11         // 49bbefcdab89674523f1
+       MOVB (BX), DL                           // 8a13
+       MOVB (R11), DL                          // 418a13
+       MOVB (BX), R11                          // 448a1b
+       MOVB (R11), R11                         // 458a1b
+       MOVQ CR2, DX                            // 0f20d2
+       MOVQ CR3, DX                            // 0f20da
+       MOVQ CR2, R11                           // 410f20d3
+       MOVQ CR3, R11                           // 410f20db
+       //TODO: MOVQ DR2, DX                    // 0f21d2
+       //TODO: MOVQ DR3, DX                    // 0f21da
+       //TODO: MOVQ DR2, R11                   // 410f21d3
+       //TODO: MOVQ DR3, R11                   // 410f21db
+       MOVAPD (BX), X2                         // 660f2813
+       MOVAPD (R11), X2                        // 66410f2813
+       MOVAPD X2, X2                           // 660f28d2 or 660f29d2
+       MOVAPD X11, X2                          // 66410f28d3 or 66440f29da
+       MOVAPD (BX), X11                        // 66440f281b
+       MOVAPD (R11), X11                       // 66450f281b
+       MOVAPD X2, X11                          // 66440f28da or 66410f29d3
+       MOVAPD X11, X11                         // 66450f28db or 66450f29db
+       MOVAPD X2, (BX)                         // 660f2913
+       MOVAPD X11, (BX)                        // 66440f291b
+       MOVAPD X2, (R11)                        // 66410f2913
+       MOVAPD X11, (R11)                       // 66450f291b
+       MOVAPS (BX), X2                         // 0f2813
+       MOVAPS (R11), X2                        // 410f2813
+       MOVAPS X2, X2                           // 0f28d2 or 0f29d2
+       MOVAPS X11, X2                          // 410f28d3 or 440f29da
+       MOVAPS (BX), X11                        // 440f281b
+       MOVAPS (R11), X11                       // 450f281b
+       MOVAPS X2, X11                          // 440f28da or 410f29d3
+       MOVAPS X11, X11                         // 450f28db or 450f29db
+       MOVAPS X2, (BX)                         // 0f2913
+       MOVAPS X11, (BX)                        // 440f291b
+       MOVAPS X2, (R11)                        // 410f2913
+       MOVAPS X11, (R11)                       // 450f291b
+       //TODO: MOVBEWW DX, (BX)                // 660f38f113
+       //TODO: MOVBEWW R11, (BX)               // 66440f38f11b
+       //TODO: MOVBEWW DX, (R11)               // 66410f38f113
+       //TODO: MOVBEWW R11, (R11)              // 66450f38f11b
+       //TODO: MOVBELL DX, (BX)                // 0f38f113
+       //TODO: MOVBELL R11, (BX)               // 440f38f11b
+       //TODO: MOVBELL DX, (R11)               // 410f38f113
+       //TODO: MOVBELL R11, (R11)              // 450f38f11b
+       //TODO: MOVBEQQ DX, (BX)                // 480f38f113
+       //TODO: MOVBEQQ R11, (BX)               // 4c0f38f11b
+       //TODO: MOVBEQQ DX, (R11)               // 490f38f113
+       //TODO: MOVBEQQ R11, (R11)              // 4d0f38f11b
+       //TODO: MOVBEWW (BX), DX                // 660f38f013
+       //TODO: MOVBEWW (R11), DX               // 66410f38f013
+       //TODO: MOVBEWW (BX), R11               // 66440f38f01b
+       //TODO: MOVBEWW (R11), R11              // 66450f38f01b
+       //TODO: MOVBELL (BX), DX                // 0f38f013
+       //TODO: MOVBELL (R11), DX               // 410f38f013
+       //TODO: MOVBELL (BX), R11               // 440f38f01b
+       //TODO: MOVBELL (R11), R11              // 450f38f01b
+       //TODO: MOVBEQQ (BX), DX                // 480f38f013
+       //TODO: MOVBEQQ (R11), DX               // 490f38f013
+       //TODO: MOVBEQQ (BX), R11               // 4c0f38f01b
+       //TODO: MOVBEQQ (R11), R11              // 4d0f38f01b
+       MOVQ (BX), M2                           // 0f6e13 or 0f6f13 or 480f6e13
+       MOVQ (R11), M2                          // 410f6e13 or 410f6f13 or 490f6e13
+       MOVQ DX, M2                             // 0f6ed2 or 480f6ed2
+       MOVQ R11, M2                            // 410f6ed3 or 490f6ed3
+       MOVQ (BX), M3                           // 0f6e1b or 0f6f1b or 480f6e1b
+       MOVQ (R11), M3                          // 410f6e1b or 410f6f1b or 490f6e1b
+       MOVQ DX, M3                             // 0f6eda or 480f6eda
+       MOVQ R11, M3                            // 410f6edb or 490f6edb
+       MOVQ M2, (BX)                           // 0f7e13 or 0f7f13 or 480f7e13
+       MOVQ M3, (BX)                           // 0f7e1b or 0f7f1b or 480f7e1b
+       MOVQ M2, (R11)                          // 410f7e13 or 410f7f13 or 490f7e13
+       MOVQ M3, (R11)                          // 410f7e1b or 410f7f1b or 490f7e1b
+       MOVQ M2, DX                             // 0f7ed2 or 480f7ed2
+       MOVQ M3, DX                             // 0f7eda or 480f7eda
+       MOVQ M2, R11                            // 410f7ed3 or 490f7ed3
+       MOVQ M3, R11                            // 410f7edb or 490f7edb
+       MOVQ X2, (BX)                           // 660f7e13 or 66480f7e13 or 660fd613
+       MOVQ X11, (BX)                          // 66440f7e1b or 664c0f7e1b or 66440fd61b
+       MOVQ X2, (R11)                          // 66410f7e13 or 66490f7e13 or 66410fd613
+       MOVQ X11, (R11)                         // 66450f7e1b or 664d0f7e1b or 66450fd61b
+       MOVQ X2, DX                             // 660f7ed2 or 66480f7ed2
+       MOVQ X11, DX                            // 66440f7eda or 664c0f7eda
+       MOVQ X2, R11                            // 66410f7ed3 or 66490f7ed3
+       MOVQ X11, R11                           // 66450f7edb or 664d0f7edb
+       MOVQ (BX), X2                           // 660f6e13 or 66480f6e13 or f30f7e13
+       MOVQ (R11), X2                          // 66410f6e13 or 66490f6e13 or f3410f7e13
+       MOVQ DX, X2                             // 660f6ed2 or 66480f6ed2
+       MOVQ R11, X2                            // 66410f6ed3 or 66490f6ed3
+       MOVQ (BX), X11                          // 66440f6e1b or 664c0f6e1b or f3440f7e1b
+       MOVQ (R11), X11                         // 66450f6e1b or 664d0f6e1b or f3450f7e1b
+       MOVQ DX, X11                            // 66440f6eda or 664c0f6eda
+       MOVQ R11, X11                           // 66450f6edb or 664d0f6edb
+       //TODO: MOVDDUP (BX), X2                // f20f1213
+       //TODO: MOVDDUP (R11), X2               // f2410f1213
+       //TODO: MOVDDUP X2, X2                  // f20f12d2
+       //TODO: MOVDDUP X11, X2                 // f2410f12d3
+       //TODO: MOVDDUP (BX), X11               // f2440f121b
+       //TODO: MOVDDUP (R11), X11              // f2450f121b
+       //TODO: MOVDDUP X2, X11                 // f2440f12da
+       //TODO: MOVDDUP X11, X11                // f2450f12db
+       MOVQ X2, M2                             // f20fd6d2
+       MOVQ X11, M2                            // f2410fd6d3
+       MOVQ X2, M3                             // f20fd6da
+       MOVQ X11, M3                            // f2410fd6db
+       MOVO (BX), X2                           // 660f6f13
+       MOVO (R11), X2                          // 66410f6f13
+       MOVO X2, X2                             // 660f6fd2 or 660f7fd2
+       MOVO X11, X2                            // 66410f6fd3 or 66440f7fda
+       MOVO (BX), X11                          // 66440f6f1b
+       MOVO (R11), X11                         // 66450f6f1b
+       MOVO X2, X11                            // 66440f6fda or 66410f7fd3
+       MOVO X11, X11                           // 66450f6fdb or 66450f7fdb
+       MOVO X2, (BX)                           // 660f7f13
+       MOVO X11, (BX)                          // 66440f7f1b
+       MOVO X2, (R11)                          // 66410f7f13
+       MOVO X11, (R11)                         // 66450f7f1b
+       MOVOU (BX), X2                          // f30f6f13
+       MOVOU (R11), X2                         // f3410f6f13
+       MOVOU X2, X2                            // f30f6fd2 or f30f7fd2
+       MOVOU X11, X2                           // f3410f6fd3 or f3440f7fda
+       MOVOU (BX), X11                         // f3440f6f1b
+       MOVOU (R11), X11                        // f3450f6f1b
+       MOVOU X2, X11                           // f3440f6fda or f3410f7fd3
+       MOVOU X11, X11                          // f3450f6fdb or f3450f7fdb
+       MOVOU X2, (BX)                          // f30f7f13
+       MOVOU X11, (BX)                         // f3440f7f1b
+       MOVOU X2, (R11)                         // f3410f7f13
+       MOVOU X11, (R11)                        // f3450f7f1b
+       MOVHLPS X2, X2                          // 0f12d2
+       MOVHLPS X11, X2                         // 410f12d3
+       MOVHLPS X2, X11                         // 440f12da
+       MOVHLPS X11, X11                        // 450f12db
+       MOVHPD X2, (BX)                         // 660f1713
+       MOVHPD X11, (BX)                        // 66440f171b
+       MOVHPD X2, (R11)                        // 66410f1713
+       MOVHPD X11, (R11)                       // 66450f171b
+       MOVHPD (BX), X2                         // 660f1613
+       MOVHPD (R11), X2                        // 66410f1613
+       MOVHPD (BX), X11                        // 66440f161b
+       MOVHPD (R11), X11                       // 66450f161b
+       MOVHPS X2, (BX)                         // 0f1713
+       MOVHPS X11, (BX)                        // 440f171b
+       MOVHPS X2, (R11)                        // 410f1713
+       MOVHPS X11, (R11)                       // 450f171b
+       MOVHPS (BX), X2                         // 0f1613
+       MOVHPS (R11), X2                        // 410f1613
+       MOVHPS (BX), X11                        // 440f161b
+       MOVHPS (R11), X11                       // 450f161b
+       MOVLHPS X2, X2                          // 0f16d2
+       MOVLHPS X11, X2                         // 410f16d3
+       MOVLHPS X2, X11                         // 440f16da
+       MOVLHPS X11, X11                        // 450f16db
+       MOVLPD X2, (BX)                         // 660f1313
+       MOVLPD X11, (BX)                        // 66440f131b
+       MOVLPD X2, (R11)                        // 66410f1313
+       MOVLPD X11, (R11)                       // 66450f131b
+       MOVLPD (BX), X2                         // 660f1213
+       MOVLPD (R11), X2                        // 66410f1213
+       MOVLPD (BX), X11                        // 66440f121b
+       MOVLPD (R11), X11                       // 66450f121b
+       MOVLPS X2, (BX)                         // 0f1313
+       MOVLPS X11, (BX)                        // 440f131b
+       MOVLPS X2, (R11)                        // 410f1313
+       MOVLPS X11, (R11)                       // 450f131b
+       MOVLPS (BX), X2                         // 0f1213
+       MOVLPS (R11), X2                        // 410f1213
+       MOVLPS (BX), X11                        // 440f121b
+       MOVLPS (R11), X11                       // 450f121b
+       MOVMSKPD X2, DX                         // 660f50d2
+       MOVMSKPD X11, DX                        // 66410f50d3
+       MOVMSKPD X2, R11                        // 66440f50da
+       MOVMSKPD X11, R11                       // 66450f50db
+       MOVMSKPS X2, DX                         // 0f50d2
+       MOVMSKPS X11, DX                        // 410f50d3
+       MOVMSKPS X2, R11                        // 440f50da
+       MOVMSKPS X11, R11                       // 450f50db
+       MOVNTO X2, (BX)                         // 660fe713
+       MOVNTO X11, (BX)                        // 66440fe71b
+       MOVNTO X2, (R11)                        // 66410fe713
+       MOVNTO X11, (R11)                       // 66450fe71b
+       //TODO: MOVNTDQA (BX), X2               // 660f382a13
+       //TODO: MOVNTDQA (R11), X2              // 66410f382a13
+       //TODO: MOVNTDQA (BX), X11              // 66440f382a1b
+       //TODO: MOVNTDQA (R11), X11             // 66450f382a1b
+       MOVNTIL DX, (BX)                        // 0fc313
+       MOVNTIL R11, (BX)                       // 440fc31b
+       MOVNTIL DX, (R11)                       // 410fc313
+       MOVNTIL R11, (R11)                      // 450fc31b
+       MOVNTIQ DX, (BX)                        // 480fc313
+       MOVNTIQ R11, (BX)                       // 4c0fc31b
+       MOVNTIQ DX, (R11)                       // 490fc313
+       MOVNTIQ R11, (R11)                      // 4d0fc31b
+       MOVNTPD X2, (BX)                        // 660f2b13
+       MOVNTPD X11, (BX)                       // 66440f2b1b
+       MOVNTPD X2, (R11)                       // 66410f2b13
+       MOVNTPD X11, (R11)                      // 66450f2b1b
+       MOVNTPS X2, (BX)                        // 0f2b13
+       MOVNTPS X11, (BX)                       // 440f2b1b
+       MOVNTPS X2, (R11)                       // 410f2b13
+       MOVNTPS X11, (R11)                      // 450f2b1b
+       MOVNTQ M2, (BX)                         // 0fe713
+       MOVNTQ M3, (BX)                         // 0fe71b
+       MOVNTQ M2, (R11)                        // 410fe713
+       MOVNTQ M3, (R11)                        // 410fe71b
+       //TODO: MOVNTSD X2, (BX)                // f20f2b13
+       //TODO: MOVNTSD X11, (BX)               // f2440f2b1b
+       //TODO: MOVNTSD X2, (R11)               // f2410f2b13
+       //TODO: MOVNTSD X11, (R11)              // f2450f2b1b
+       //TODO: MOVNTSS X2, (BX)                // f30f2b13
+       //TODO: MOVNTSS X11, (BX)               // f3440f2b1b
+       //TODO: MOVNTSS X2, (R11)               // f3410f2b13
+       //TODO: MOVNTSS X11, (R11)              // f3450f2b1b
+       //TODO: MOVQ M2, M2                     // 0f6fd2 or 0f7fd2
+       //TODO: MOVQ M3, M2                     // 0f6fd3 or 0f7fda
+       //TODO: MOVQ M2, M3                     // 0f6fda or 0f7fd3
+       //TODO: MOVQ M3, M3                     // 0f6fdb or 0f7fdb
+       MOVQ X2, X2                             // f30f7ed2 or 660fd6d2
+       MOVQ X11, X2                            // f3410f7ed3 or 66440fd6da
+       MOVQ X2, X11                            // f3440f7eda or 66410fd6d3
+       MOVQ X11, X11                           // f3450f7edb or 66450fd6db
+       MOVQOZX M2, X2                          // f30fd6d2
+       MOVQOZX M3, X2                          // f30fd6d3
+       MOVQOZX M2, X11                         // f3440fd6da
+       MOVQOZX M3, X11                         // f3440fd6db
+       MOVSB                                   // a4
+       MOVSL                                   // a5
+       //TODO: MOVSD (BX), X2                  // f20f1013
+       //TODO: MOVSD (R11), X2                 // f2410f1013
+       //TODO: MOVSD X2, X2                    // f20f10d2 or f20f11d2
+       //TODO: MOVSD X11, X2                   // f2410f10d3 or f2440f11da
+       //TODO: MOVSD (BX), X11                 // f2440f101b
+       //TODO: MOVSD (R11), X11                // f2450f101b
+       //TODO: MOVSD X2, X11                   // f2440f10da or f2410f11d3
+       //TODO: MOVSD X11, X11                  // f2450f10db or f2450f11db
+       //TODO: MOVSD X2, (BX)                  // f20f1113
+       //TODO: MOVSD X11, (BX)                 // f2440f111b
+       //TODO: MOVSD X2, (R11)                 // f2410f1113
+       //TODO: MOVSD X11, (R11)                // f2450f111b
+       //TODO: MOVSHDUP (BX), X2               // f30f1613
+       //TODO: MOVSHDUP (R11), X2              // f3410f1613
+       //TODO: MOVSHDUP X2, X2                 // f30f16d2
+       //TODO: MOVSHDUP X11, X2                // f3410f16d3
+       //TODO: MOVSHDUP (BX), X11              // f3440f161b
+       //TODO: MOVSHDUP (R11), X11             // f3450f161b
+       //TODO: MOVSHDUP X2, X11                // f3440f16da
+       //TODO: MOVSHDUP X11, X11               // f3450f16db
+       //TODO: MOVSLDUP (BX), X2               // f30f1213
+       //TODO: MOVSLDUP (R11), X2              // f3410f1213
+       //TODO: MOVSLDUP X2, X2                 // f30f12d2
+       //TODO: MOVSLDUP X11, X2                // f3410f12d3
+       //TODO: MOVSLDUP (BX), X11              // f3440f121b
+       //TODO: MOVSLDUP (R11), X11             // f3450f121b
+       //TODO: MOVSLDUP X2, X11                // f3440f12da
+       //TODO: MOVSLDUP X11, X11               // f3450f12db
+       MOVSQ                                   // 48a5
+       MOVSS (BX), X2                          // f30f1013
+       MOVSS (R11), X2                         // f3410f1013
+       MOVSS X2, X2                            // f30f10d2 or f30f11d2
+       MOVSS X11, X2                           // f3410f10d3 or f3440f11da
+       MOVSS (BX), X11                         // f3440f101b
+       MOVSS (R11), X11                        // f3450f101b
+       MOVSS X2, X11                           // f3440f10da or f3410f11d3
+       MOVSS X11, X11                          // f3450f10db or f3450f11db
+       MOVSS X2, (BX)                          // f30f1113
+       MOVSS X11, (BX)                         // f3440f111b
+       MOVSS X2, (R11)                         // f3410f1113
+       MOVSS X11, (R11)                        // f3450f111b
+       MOVSW                                   // 66a5
+       //TODO: MOVSWW (BX), DX                 // 660fbf13
+       //TODO: MOVSWW (R11), DX                // 66410fbf13
+       //TODO: MOVSWW DX, DX                   // 660fbfd2
+       //TODO: MOVSWW R11, DX                  // 66410fbfd3
+       //TODO: MOVSWW (BX), R11                // 66440fbf1b
+       //TODO: MOVSWW (R11), R11               // 66450fbf1b
+       //TODO: MOVSWW DX, R11                  // 66440fbfda
+       //TODO: MOVSWW R11, R11                 // 66450fbfdb
+       MOVBWSX (BX), DX                        // 660fbe13
+       MOVBWSX (R11), DX                       // 66410fbe13
+       MOVBWSX DL, DX                          // 660fbed2
+       MOVBWSX R11, DX                         // 66410fbed3
+       MOVBWSX (BX), R11                       // 66440fbe1b
+       MOVBWSX (R11), R11                      // 66450fbe1b
+       MOVBWSX DL, R11                         // 66440fbeda
+       MOVBWSX R11, R11                        // 66450fbedb
+       MOVWLSX (BX), DX                        // 0fbf13
+       MOVWLSX (R11), DX                       // 410fbf13
+       MOVWLSX DX, DX                          // 0fbfd2
+       MOVWLSX R11, DX                         // 410fbfd3
+       MOVWLSX (BX), R11                       // 440fbf1b
+       MOVWLSX (R11), R11                      // 450fbf1b
+       MOVWLSX DX, R11                         // 440fbfda
+       MOVWLSX R11, R11                        // 450fbfdb
+       MOVBLSX (BX), DX                        // 0fbe13
+       MOVBLSX (R11), DX                       // 410fbe13
+       MOVBLSX DL, DX                          // 0fbed2
+       MOVBLSX R11, DX                         // 410fbed3
+       MOVBLSX (BX), R11                       // 440fbe1b
+       MOVBLSX (R11), R11                      // 450fbe1b
+       MOVBLSX DL, R11                         // 440fbeda
+       MOVBLSX R11, R11                        // 450fbedb
+       MOVWQSX (BX), DX                        // 480fbf13 or 666313
+       MOVWQSX (R11), DX                       // 490fbf13 or 66416313
+       MOVWQSX DX, DX                          // 480fbfd2 or 6663d2
+       MOVWQSX R11, DX                         // 490fbfd3 or 664163d3
+       MOVWQSX (BX), R11                       // 4c0fbf1b or 6644631b
+       MOVWQSX (R11), R11                      // 4d0fbf1b or 6645631b
+       MOVWQSX DX, R11                         // 4c0fbfda or 664463da
+       MOVWQSX R11, R11                        // 4d0fbfdb or 664563db
+       MOVBQSX (BX), DX                        // 480fbe13
+       MOVBQSX (R11), DX                       // 490fbe13
+       MOVBQSX DL, DX                          // 480fbed2
+       MOVBQSX R11, DX                         // 490fbed3
+       MOVBQSX (BX), R11                       // 4c0fbe1b
+       MOVBQSX (R11), R11                      // 4d0fbe1b
+       MOVBQSX DL, R11                         // 4c0fbeda
+       MOVBQSX R11, R11                        // 4d0fbedb
+       MOVLQSX (BX), DX                        // 6313 or 486313
+       MOVLQSX (R11), DX                       // 416313 or 496313
+       MOVLQSX DX, DX                          // 63d2 or 4863d2
+       MOVLQSX R11, DX                         // 4163d3 or 4963d3
+       MOVLQSX (BX), R11                       // 44631b or 4c631b
+       MOVLQSX (R11), R11                      // 45631b or 4d631b
+       MOVLQSX DX, R11                         // 4463da or 4c63da
+       MOVLQSX R11, R11                        // 4563db or 4d63db
+       MOVUPD (BX), X2                         // 660f1013
+       MOVUPD (R11), X2                        // 66410f1013
+       MOVUPD X2, X2                           // 660f10d2 or 660f11d2
+       MOVUPD X11, X2                          // 66410f10d3 or 66440f11da
+       MOVUPD (BX), X11                        // 66440f101b
+       MOVUPD (R11), X11                       // 66450f101b
+       MOVUPD X2, X11                          // 66440f10da or 66410f11d3
+       MOVUPD X11, X11                         // 66450f10db or 66450f11db
+       MOVUPD X2, (BX)                         // 660f1113
+       MOVUPD X11, (BX)                        // 66440f111b
+       MOVUPD X2, (R11)                        // 66410f1113
+       MOVUPD X11, (R11)                       // 66450f111b
+       MOVUPS (BX), X2                         // 0f1013
+       MOVUPS (R11), X2                        // 410f1013
+       MOVUPS X2, X2                           // 0f10d2 or 0f11d2
+       MOVUPS X11, X2                          // 410f10d3 or 440f11da
+       MOVUPS (BX), X11                        // 440f101b
+       MOVUPS (R11), X11                       // 450f101b
+       MOVUPS X2, X11                          // 440f10da or 410f11d3
+       MOVUPS X11, X11                         // 450f10db or 450f11db
+       MOVUPS X2, (BX)                         // 0f1113
+       MOVUPS X11, (BX)                        // 440f111b
+       MOVUPS X2, (R11)                        // 410f1113
+       MOVUPS X11, (R11)                       // 450f111b
+       //TODO: MOVZWW (BX), DX                 // 660fb713
+       //TODO: MOVZWW (R11), DX                // 66410fb713
+       //TODO: MOVZWW DX, DX                   // 660fb7d2
+       //TODO: MOVZWW R11, DX                  // 66410fb7d3
+       //TODO: MOVZWW (BX), R11                // 66440fb71b
+       //TODO: MOVZWW (R11), R11               // 66450fb71b
+       //TODO: MOVZWW DX, R11                  // 66440fb7da
+       //TODO: MOVZWW R11, R11                 // 66450fb7db
+       MOVBWZX (BX), DX                        // 660fb613
+       MOVBWZX (R11), DX                       // 66410fb613
+       MOVBWZX DL, DX                          // 660fb6d2
+       MOVBWZX R11, DX                         // 66410fb6d3
+       MOVBWZX (BX), R11                       // 66440fb61b
+       MOVBWZX (R11), R11                      // 66450fb61b
+       MOVBWZX DL, R11                         // 66440fb6da
+       MOVBWZX R11, R11                        // 66450fb6db
+       MOVWLZX (BX), DX                        // 0fb713
+       MOVWLZX (R11), DX                       // 410fb713
+       MOVWLZX DX, DX                          // 0fb7d2
+       MOVWLZX R11, DX                         // 410fb7d3
+       MOVWLZX (BX), R11                       // 440fb71b
+       MOVWLZX (R11), R11                      // 450fb71b
+       MOVWLZX DX, R11                         // 440fb7da
+       MOVWLZX R11, R11                        // 450fb7db
+       MOVBLZX (BX), DX                        // 0fb613
+       MOVBLZX (R11), DX                       // 410fb613
+       MOVBLZX DL, DX                          // 0fb6d2
+       MOVBLZX R11, DX                         // 410fb6d3
+       MOVBLZX (BX), R11                       // 440fb61b
+       MOVBLZX (R11), R11                      // 450fb61b
+       MOVBLZX DL, R11                         // 440fb6da
+       MOVBLZX R11, R11                        // 450fb6db
+       MOVWQZX (BX), DX                        // 480fb713
+       MOVWQZX (R11), DX                       // 490fb713
+       MOVWQZX DX, DX                          // 480fb7d2
+       MOVWQZX R11, DX                         // 490fb7d3
+       MOVWQZX (BX), R11                       // 4c0fb71b
+       MOVWQZX (R11), R11                      // 4d0fb71b
+       MOVWQZX DX, R11                         // 4c0fb7da
+       MOVWQZX R11, R11                        // 4d0fb7db
+       //TODO: MOVBQZX (BX), DX                // 480fb613
+       //TODO: MOVBQZX (R11), DX               // 490fb613
+       //TODO: MOVBQZX DL, DX                  // 480fb6d2
+       //TODO: MOVBQZX R11, DX                 // 490fb6d3
+       //TODO: MOVBQZX (BX), R11               // 4c0fb61b
+       //TODO: MOVBQZX (R11), R11              // 4d0fb61b
+       //TODO: MOVBQZX DL, R11                 // 4c0fb6da
+       //TODO: MOVBQZX R11, R11                // 4d0fb6db
+       //TODO: MPSADBW $7, (BX), X2            // 660f3a421307
+       //TODO: MPSADBW $7, (R11), X2           // 66410f3a421307
+       //TODO: MPSADBW $7, X2, X2              // 660f3a42d207
+       //TODO: MPSADBW $7, X11, X2             // 66410f3a42d307
+       //TODO: MPSADBW $7, (BX), X11           // 66440f3a421b07
+       //TODO: MPSADBW $7, (R11), X11          // 66450f3a421b07
+       //TODO: MPSADBW $7, X2, X11             // 66440f3a42da07
+       //TODO: MPSADBW $7, X11, X11            // 66450f3a42db07
+       MULW (BX)                               // 66f723
+       MULW (R11)                              // 6641f723
+       MULW DX                                 // 66f7e2
+       MULW R11                                // 6641f7e3
+       MULL (BX)                               // f723
+       MULL (R11)                              // 41f723
+       MULL DX                                 // f7e2
+       MULL R11                                // 41f7e3
+       MULQ (BX)                               // 48f723
+       MULQ (R11)                              // 49f723
+       MULQ DX                                 // 48f7e2
+       MULQ R11                                // 49f7e3
+       MULB (BX)                               // f623
+       MULB (R11)                              // 41f623
+       MULB DL                                 // f6e2
+       MULB R11                                // 41f6e3
+       MULPD (BX), X2                          // 660f5913
+       MULPD (R11), X2                         // 66410f5913
+       MULPD X2, X2                            // 660f59d2
+       MULPD X11, X2                           // 66410f59d3
+       MULPD (BX), X11                         // 66440f591b
+       MULPD (R11), X11                        // 66450f591b
+       MULPD X2, X11                           // 66440f59da
+       MULPD X11, X11                          // 66450f59db
+       MULPS (BX), X2                          // 0f5913
+       MULPS (R11), X2                         // 410f5913
+       MULPS X2, X2                            // 0f59d2
+       MULPS X11, X2                           // 410f59d3
+       MULPS (BX), X11                         // 440f591b
+       MULPS (R11), X11                        // 450f591b
+       MULPS X2, X11                           // 440f59da
+       MULPS X11, X11                          // 450f59db
+       MULSD (BX), X2                          // f20f5913
+       MULSD (R11), X2                         // f2410f5913
+       MULSD X2, X2                            // f20f59d2
+       MULSD X11, X2                           // f2410f59d3
+       MULSD (BX), X11                         // f2440f591b
+       MULSD (R11), X11                        // f2450f591b
+       MULSD X2, X11                           // f2440f59da
+       MULSD X11, X11                          // f2450f59db
+       MULSS (BX), X2                          // f30f5913
+       MULSS (R11), X2                         // f3410f5913
+       MULSS X2, X2                            // f30f59d2
+       MULSS X11, X2                           // f3410f59d3
+       MULSS (BX), X11                         // f3440f591b
+       MULSS (R11), X11                        // f3450f591b
+       MULSS X2, X11                           // f3440f59da
+       MULSS X11, X11                          // f3450f59db
+       MULXL (BX), R9, DX                      // c4e233f613
+       MULXL (R11), R9, DX                     // c4c233f613
+       MULXL DX, R9, DX                        // c4e233f6d2
+       MULXL R11, R9, DX                       // c4c233f6d3
+       MULXL (BX), R9, R11                     // c46233f61b
+       MULXL (R11), R9, R11                    // c44233f61b
+       MULXL DX, R9, R11                       // c46233f6da
+       MULXL R11, R9, R11                      // c44233f6db
+       MULXQ (BX), R14, DX                     // c4e28bf613
+       MULXQ (R11), R14, DX                    // c4c28bf613
+       MULXQ DX, R14, DX                       // c4e28bf6d2
+       MULXQ R11, R14, DX                      // c4c28bf6d3
+       MULXQ (BX), R14, R11                    // c4628bf61b
+       MULXQ (R11), R14, R11                   // c4428bf61b
+       MULXQ DX, R14, R11                      // c4628bf6da
+       MULXQ R11, R14, R11                     // c4428bf6db
+       //TODO: MWAIT                           // 0f01c9
+       NEGW (BX)                               // 66f71b
+       NEGW (R11)                              // 6641f71b
+       NEGW DX                                 // 66f7da
+       NEGW R11                                // 6641f7db
+       NEGL (BX)                               // f71b
+       NEGL (R11)                              // 41f71b
+       NEGL DX                                 // f7da
+       NEGL R11                                // 41f7db
+       NEGQ (BX)                               // 48f71b
+       NEGQ (R11)                              // 49f71b
+       NEGQ DX                                 // 48f7da
+       NEGQ R11                                // 49f7db
+       NEGB (BX)                               // f61b
+       NEGB (R11)                              // 41f61b
+       NEGB DL                                 // f6da
+       NEGB R11                                // 41f6db
+       //TODO: NOPW (BX)                       // 660f1f03
+       //TODO: NOPW (R11)                      // 66410f1f03
+       //TODO: NOPW DX                         // 660f1fc2
+       //TODO: NOPW R11                        // 66410f1fc3
+       //TODO: NOPL (BX)                       // 0f1f03
+       //TODO: NOPL (R11)                      // 410f1f03
+       //TODO: NOPL DX                         // 0f1fc2
+       //TODO: NOPL R11                        // 410f1fc3
+       NOTW (BX)                               // 66f713
+       NOTW (R11)                              // 6641f713
+       NOTW DX                                 // 66f7d2
+       NOTW R11                                // 6641f7d3
+       NOTL (BX)                               // f713
+       NOTL (R11)                              // 41f713
+       NOTL DX                                 // f7d2
+       NOTL R11                                // 41f7d3
+       NOTQ (BX)                               // 48f713
+       NOTQ (R11)                              // 49f713
+       NOTQ DX                                 // 48f7d2
+       NOTQ R11                                // 49f7d3
+       NOTB (BX)                               // f613
+       NOTB (R11)                              // 41f613
+       NOTB DL                                 // f6d2
+       NOTB R11                                // 41f6d3
+       ORB $7, AL                              // 0c07
+       ORW $61731, AX                          // 660d23f1
+       ORL $4045620583, AX                     // 0d674523f1
+       ORQ $-249346713, AX                     // 480d674523f1
+       ORW $61731, (BX)                        // 66810b23f1
+       ORW $61731, (R11)                       // 6641810b23f1
+       ORW $61731, DX                          // 6681ca23f1
+       ORW $61731, R11                         // 664181cb23f1
+       ORW $7, (BX)                            // 66830b07
+       ORW $7, (R11)                           // 6641830b07
+       ORW $7, DX                              // 6683ca07
+       ORW $7, R11                             // 664183cb07
+       ORW DX, (BX)                            // 660913
+       ORW R11, (BX)                           // 6644091b
+       ORW DX, (R11)                           // 66410913
+       ORW R11, (R11)                          // 6645091b
+       ORW DX, DX                              // 6609d2 or 660bd2
+       ORW R11, DX                             // 664409da or 66410bd3
+       ORW DX, R11                             // 664109d3 or 66440bda
+       ORW R11, R11                            // 664509db or 66450bdb
+       ORL $4045620583, (BX)                   // 810b674523f1
+       ORL $4045620583, (R11)                  // 41810b674523f1
+       ORL $4045620583, DX                     // 81ca674523f1
+       ORL $4045620583, R11                    // 4181cb674523f1
+       ORL $7, (BX)                            // 830b07
+       ORL $7, (R11)                           // 41830b07
+       ORL $7, DX                              // 83ca07
+       ORL $7, R11                             // 4183cb07
+       ORL DX, (BX)                            // 0913
+       ORL R11, (BX)                           // 44091b
+       ORL DX, (R11)                           // 410913
+       ORL R11, (R11)                          // 45091b
+       ORL DX, DX                              // 09d2 or 0bd2
+       ORL R11, DX                             // 4409da or 410bd3
+       ORL DX, R11                             // 4109d3 or 440bda
+       ORL R11, R11                            // 4509db or 450bdb
+       ORQ $-249346713, (BX)                   // 48810b674523f1
+       ORQ $-249346713, (R11)                  // 49810b674523f1
+       ORQ $-249346713, DX                     // 4881ca674523f1
+       ORQ $-249346713, R11                    // 4981cb674523f1
+       ORQ $7, (BX)                            // 48830b07
+       ORQ $7, (R11)                           // 49830b07
+       ORQ $7, DX                              // 4883ca07
+       ORQ $7, R11                             // 4983cb07
+       ORQ DX, (BX)                            // 480913
+       ORQ R11, (BX)                           // 4c091b
+       ORQ DX, (R11)                           // 490913
+       ORQ R11, (R11)                          // 4d091b
+       ORQ DX, DX                              // 4809d2 or 480bd2
+       ORQ R11, DX                             // 4c09da or 490bd3
+       ORQ DX, R11                             // 4909d3 or 4c0bda
+       ORQ R11, R11                            // 4d09db or 4d0bdb
+       ORB $7, (BX)                            // 800b07
+       ORB $7, (R11)                           // 41800b07
+       ORB $7, DL                              // 80ca07
+       ORB $7, R11                             // 4180cb07
+       ORB DL, (BX)                            // 0813
+       ORB R11, (BX)                           // 44081b
+       ORB DL, (R11)                           // 410813
+       ORB R11, (R11)                          // 45081b
+       ORB DL, DL                              // 08d2 or 0ad2
+       ORB R11, DL                             // 4408da or 410ad3
+       ORB DL, R11                             // 4108d3 or 440ada
+       ORB R11, R11                            // 4508db or 450adb
+       ORW (BX), DX                            // 660b13
+       ORW (R11), DX                           // 66410b13
+       ORW (BX), R11                           // 66440b1b
+       ORW (R11), R11                          // 66450b1b
+       ORL (BX), DX                            // 0b13
+       ORL (R11), DX                           // 410b13
+       ORL (BX), R11                           // 440b1b
+       ORL (R11), R11                          // 450b1b
+       ORQ (BX), DX                            // 480b13
+       ORQ (R11), DX                           // 490b13
+       ORQ (BX), R11                           // 4c0b1b
+       ORQ (R11), R11                          // 4d0b1b
+       ORB (BX), DL                            // 0a13
+       ORB (R11), DL                           // 410a13
+       ORB (BX), R11                           // 440a1b
+       ORB (R11), R11                          // 450a1b
+       ORPD (BX), X2                           // 660f5613
+       ORPD (R11), X2                          // 66410f5613
+       ORPD X2, X2                             // 660f56d2
+       ORPD X11, X2                            // 66410f56d3
+       ORPD (BX), X11                          // 66440f561b
+       ORPD (R11), X11                         // 66450f561b
+       ORPD X2, X11                            // 66440f56da
+       ORPD X11, X11                           // 66450f56db
+       ORPS (BX), X2                           // 0f5613
+       ORPS (R11), X2                          // 410f5613
+       ORPS X2, X2                             // 0f56d2
+       ORPS X11, X2                            // 410f56d3
+       ORPS (BX), X11                          // 440f561b
+       ORPS (R11), X11                         // 450f561b
+       ORPS X2, X11                            // 440f56da
+       ORPS X11, X11                           // 450f56db
+       //TODO: OUTB AL, DX                     // ee
+       //TODO: OUTW AX, DX                     // 66ef
+       //TODO: OUTL AX, DX                     // ef
+       //TODO: OUTB AL, $7                     // e607
+       //TODO: OUTW AX, $7                     // 66e707
+       //TODO: OUTL AX, $7                     // e707
+       OUTSB                                   // 6e
+       OUTSL                                   // 6f
+       OUTSW                                   // 666f
+       //TODO: PABSB (BX), M2                  // 0f381c13
+       //TODO: PABSB (R11), M2                 // 410f381c13
+       //TODO: PABSB M2, M2                    // 0f381cd2
+       //TODO: PABSB M3, M2                    // 0f381cd3
+       //TODO: PABSB (BX), M3                  // 0f381c1b
+       //TODO: PABSB (R11), M3                 // 410f381c1b
+       //TODO: PABSB M2, M3                    // 0f381cda
+       //TODO: PABSB M3, M3                    // 0f381cdb
+       //TODO: PABSB (BX), X2                  // 660f381c13
+       //TODO: PABSB (R11), X2                 // 66410f381c13
+       //TODO: PABSB X2, X2                    // 660f381cd2
+       //TODO: PABSB X11, X2                   // 66410f381cd3
+       //TODO: PABSB (BX), X11                 // 66440f381c1b
+       //TODO: PABSB (R11), X11                // 66450f381c1b
+       //TODO: PABSB X2, X11                   // 66440f381cda
+       //TODO: PABSB X11, X11                  // 66450f381cdb
+       //TODO: PABSD (BX), M2                  // 0f381e13
+       //TODO: PABSD (R11), M2                 // 410f381e13
+       //TODO: PABSD M2, M2                    // 0f381ed2
+       //TODO: PABSD M3, M2                    // 0f381ed3
+       //TODO: PABSD (BX), M3                  // 0f381e1b
+       //TODO: PABSD (R11), M3                 // 410f381e1b
+       //TODO: PABSD M2, M3                    // 0f381eda
+       //TODO: PABSD M3, M3                    // 0f381edb
+       //TODO: PABSD (BX), X2                  // 660f381e13
+       //TODO: PABSD (R11), X2                 // 66410f381e13
+       //TODO: PABSD X2, X2                    // 660f381ed2
+       //TODO: PABSD X11, X2                   // 66410f381ed3
+       //TODO: PABSD (BX), X11                 // 66440f381e1b
+       //TODO: PABSD (R11), X11                // 66450f381e1b
+       //TODO: PABSD X2, X11                   // 66440f381eda
+       //TODO: PABSD X11, X11                  // 66450f381edb
+       //TODO: PABSW (BX), M2                  // 0f381d13
+       //TODO: PABSW (R11), M2                 // 410f381d13
+       //TODO: PABSW M2, M2                    // 0f381dd2
+       //TODO: PABSW M3, M2                    // 0f381dd3
+       //TODO: PABSW (BX), M3                  // 0f381d1b
+       //TODO: PABSW (R11), M3                 // 410f381d1b
+       //TODO: PABSW M2, M3                    // 0f381dda
+       //TODO: PABSW M3, M3                    // 0f381ddb
+       //TODO: PABSW (BX), X2                  // 660f381d13
+       //TODO: PABSW (R11), X2                 // 66410f381d13
+       //TODO: PABSW X2, X2                    // 660f381dd2
+       //TODO: PABSW X11, X2                   // 66410f381dd3
+       //TODO: PABSW (BX), X11                 // 66440f381d1b
+       //TODO: PABSW (R11), X11                // 66450f381d1b
+       //TODO: PABSW X2, X11                   // 66440f381dda
+       //TODO: PABSW X11, X11                  // 66450f381ddb
+       PACKSSLW (BX), M2                       // 0f6b13
+       PACKSSLW (R11), M2                      // 410f6b13
+       PACKSSLW M2, M2                         // 0f6bd2
+       PACKSSLW M3, M2                         // 0f6bd3
+       PACKSSLW (BX), M3                       // 0f6b1b
+       PACKSSLW (R11), M3                      // 410f6b1b
+       PACKSSLW M2, M3                         // 0f6bda
+       PACKSSLW M3, M3                         // 0f6bdb
+       PACKSSLW (BX), X2                       // 660f6b13
+       PACKSSLW (R11), X2                      // 66410f6b13
+       PACKSSLW X2, X2                         // 660f6bd2
+       PACKSSLW X11, X2                        // 66410f6bd3
+       PACKSSLW (BX), X11                      // 66440f6b1b
+       PACKSSLW (R11), X11                     // 66450f6b1b
+       PACKSSLW X2, X11                        // 66440f6bda
+       PACKSSLW X11, X11                       // 66450f6bdb
+       PACKSSWB (BX), M2                       // 0f6313
+       PACKSSWB (R11), M2                      // 410f6313
+       PACKSSWB M2, M2                         // 0f63d2
+       PACKSSWB M3, M2                         // 0f63d3
+       PACKSSWB (BX), M3                       // 0f631b
+       PACKSSWB (R11), M3                      // 410f631b
+       PACKSSWB M2, M3                         // 0f63da
+       PACKSSWB M3, M3                         // 0f63db
+       PACKSSWB (BX), X2                       // 660f6313
+       PACKSSWB (R11), X2                      // 66410f6313
+       PACKSSWB X2, X2                         // 660f63d2
+       PACKSSWB X11, X2                        // 66410f63d3
+       PACKSSWB (BX), X11                      // 66440f631b
+       PACKSSWB (R11), X11                     // 66450f631b
+       PACKSSWB X2, X11                        // 66440f63da
+       PACKSSWB X11, X11                       // 66450f63db
+       //TODO: PACKUSDW (BX), X2               // 660f382b13
+       //TODO: PACKUSDW (R11), X2              // 66410f382b13
+       //TODO: PACKUSDW X2, X2                 // 660f382bd2
+       //TODO: PACKUSDW X11, X2                // 66410f382bd3
+       //TODO: PACKUSDW (BX), X11              // 66440f382b1b
+       //TODO: PACKUSDW (R11), X11             // 66450f382b1b
+       //TODO: PACKUSDW X2, X11                // 66440f382bda
+       //TODO: PACKUSDW X11, X11               // 66450f382bdb
+       PACKUSWB (BX), M2                       // 0f6713
+       PACKUSWB (R11), M2                      // 410f6713
+       PACKUSWB M2, M2                         // 0f67d2
+       PACKUSWB M3, M2                         // 0f67d3
+       PACKUSWB (BX), M3                       // 0f671b
+       PACKUSWB (R11), M3                      // 410f671b
+       PACKUSWB M2, M3                         // 0f67da
+       PACKUSWB M3, M3                         // 0f67db
+       PACKUSWB (BX), X2                       // 660f6713
+       PACKUSWB (R11), X2                      // 66410f6713
+       PACKUSWB X2, X2                         // 660f67d2
+       PACKUSWB X11, X2                        // 66410f67d3
+       PACKUSWB (BX), X11                      // 66440f671b
+       PACKUSWB (R11), X11                     // 66450f671b
+       PACKUSWB X2, X11                        // 66440f67da
+       PACKUSWB X11, X11                       // 66450f67db
+       PADDB (BX), M2                          // 0ffc13
+       PADDB (R11), M2                         // 410ffc13
+       PADDB M2, M2                            // 0ffcd2
+       PADDB M3, M2                            // 0ffcd3
+       PADDB (BX), M3                          // 0ffc1b
+       PADDB (R11), M3                         // 410ffc1b
+       PADDB M2, M3                            // 0ffcda
+       PADDB M3, M3                            // 0ffcdb
+       PADDB (BX), X2                          // 660ffc13
+       PADDB (R11), X2                         // 66410ffc13
+       PADDB X2, X2                            // 660ffcd2
+       PADDB X11, X2                           // 66410ffcd3
+       PADDB (BX), X11                         // 66440ffc1b
+       PADDB (R11), X11                        // 66450ffc1b
+       PADDB X2, X11                           // 66440ffcda
+       PADDB X11, X11                          // 66450ffcdb
+       PADDL (BX), M2                          // 0ffe13
+       PADDL (R11), M2                         // 410ffe13
+       PADDL M2, M2                            // 0ffed2
+       PADDL M3, M2                            // 0ffed3
+       PADDL (BX), M3                          // 0ffe1b
+       PADDL (R11), M3                         // 410ffe1b
+       PADDL M2, M3                            // 0ffeda
+       PADDL M3, M3                            // 0ffedb
+       PADDL (BX), X2                          // 660ffe13
+       PADDL (R11), X2                         // 66410ffe13
+       PADDL X2, X2                            // 660ffed2
+       PADDL X11, X2                           // 66410ffed3
+       PADDL (BX), X11                         // 66440ffe1b
+       PADDL (R11), X11                        // 66450ffe1b
+       PADDL X2, X11                           // 66440ffeda
+       PADDL X11, X11                          // 66450ffedb
+       //TODO: PADDQ (BX), M2                  // 0fd413
+       //TODO: PADDQ (R11), M2                 // 410fd413
+       //TODO: PADDQ M2, M2                    // 0fd4d2
+       //TODO: PADDQ M3, M2                    // 0fd4d3
+       //TODO: PADDQ (BX), M3                  // 0fd41b
+       //TODO: PADDQ (R11), M3                 // 410fd41b
+       //TODO: PADDQ M2, M3                    // 0fd4da
+       //TODO: PADDQ M3, M3                    // 0fd4db
+       PADDQ (BX), X2                          // 660fd413
+       PADDQ (R11), X2                         // 66410fd413
+       PADDQ X2, X2                            // 660fd4d2
+       PADDQ X11, X2                           // 66410fd4d3
+       PADDQ (BX), X11                         // 66440fd41b
+       PADDQ (R11), X11                        // 66450fd41b
+       PADDQ X2, X11                           // 66440fd4da
+       PADDQ X11, X11                          // 66450fd4db
+       PADDSB (BX), M2                         // 0fec13
+       PADDSB (R11), M2                        // 410fec13
+       PADDSB M2, M2                           // 0fecd2
+       PADDSB M3, M2                           // 0fecd3
+       PADDSB (BX), M3                         // 0fec1b
+       PADDSB (R11), M3                        // 410fec1b
+       PADDSB M2, M3                           // 0fecda
+       PADDSB M3, M3                           // 0fecdb
+       PADDSB (BX), X2                         // 660fec13
+       PADDSB (R11), X2                        // 66410fec13
+       PADDSB X2, X2                           // 660fecd2
+       PADDSB X11, X2                          // 66410fecd3
+       PADDSB (BX), X11                        // 66440fec1b
+       PADDSB (R11), X11                       // 66450fec1b
+       PADDSB X2, X11                          // 66440fecda
+       PADDSB X11, X11                         // 66450fecdb
+       PADDSW (BX), M2                         // 0fed13
+       PADDSW (R11), M2                        // 410fed13
+       PADDSW M2, M2                           // 0fedd2
+       PADDSW M3, M2                           // 0fedd3
+       PADDSW (BX), M3                         // 0fed1b
+       PADDSW (R11), M3                        // 410fed1b
+       PADDSW M2, M3                           // 0fedda
+       PADDSW M3, M3                           // 0feddb
+       PADDSW (BX), X2                         // 660fed13
+       PADDSW (R11), X2                        // 66410fed13
+       PADDSW X2, X2                           // 660fedd2
+       PADDSW X11, X2                          // 66410fedd3
+       PADDSW (BX), X11                        // 66440fed1b
+       PADDSW (R11), X11                       // 66450fed1b
+       PADDSW X2, X11                          // 66440fedda
+       PADDSW X11, X11                         // 66450feddb
+       PADDUSB (BX), M2                        // 0fdc13
+       PADDUSB (R11), M2                       // 410fdc13
+       PADDUSB M2, M2                          // 0fdcd2
+       PADDUSB M3, M2                          // 0fdcd3
+       PADDUSB (BX), M3                        // 0fdc1b
+       PADDUSB (R11), M3                       // 410fdc1b
+       PADDUSB M2, M3                          // 0fdcda
+       PADDUSB M3, M3                          // 0fdcdb
+       PADDUSB (BX), X2                        // 660fdc13
+       PADDUSB (R11), X2                       // 66410fdc13
+       PADDUSB X2, X2                          // 660fdcd2
+       PADDUSB X11, X2                         // 66410fdcd3
+       PADDUSB (BX), X11                       // 66440fdc1b
+       PADDUSB (R11), X11                      // 66450fdc1b
+       PADDUSB X2, X11                         // 66440fdcda
+       PADDUSB X11, X11                        // 66450fdcdb
+       PADDUSW (BX), M2                        // 0fdd13
+       PADDUSW (R11), M2                       // 410fdd13
+       PADDUSW M2, M2                          // 0fddd2
+       PADDUSW M3, M2                          // 0fddd3
+       PADDUSW (BX), M3                        // 0fdd1b
+       PADDUSW (R11), M3                       // 410fdd1b
+       PADDUSW M2, M3                          // 0fddda
+       PADDUSW M3, M3                          // 0fdddb
+       PADDUSW (BX), X2                        // 660fdd13
+       PADDUSW (R11), X2                       // 66410fdd13
+       PADDUSW X2, X2                          // 660fddd2
+       PADDUSW X11, X2                         // 66410fddd3
+       PADDUSW (BX), X11                       // 66440fdd1b
+       PADDUSW (R11), X11                      // 66450fdd1b
+       PADDUSW X2, X11                         // 66440fddda
+       PADDUSW X11, X11                        // 66450fdddb
+       PADDW (BX), M2                          // 0ffd13
+       PADDW (R11), M2                         // 410ffd13
+       PADDW M2, M2                            // 0ffdd2
+       PADDW M3, M2                            // 0ffdd3
+       PADDW (BX), M3                          // 0ffd1b
+       PADDW (R11), M3                         // 410ffd1b
+       PADDW M2, M3                            // 0ffdda
+       PADDW M3, M3                            // 0ffddb
+       PADDW (BX), X2                          // 660ffd13
+       PADDW (R11), X2                         // 66410ffd13
+       PADDW X2, X2                            // 660ffdd2
+       PADDW X11, X2                           // 66410ffdd3
+       PADDW (BX), X11                         // 66440ffd1b
+       PADDW (R11), X11                        // 66450ffd1b
+       PADDW X2, X11                           // 66440ffdda
+       PADDW X11, X11                          // 66450ffddb
+       //TODO: PALIGNR $7, (BX), M2            // 0f3a0f1307
+       //TODO: PALIGNR $7, (R11), M2           // 410f3a0f1307
+       //TODO: PALIGNR $7, M2, M2              // 0f3a0fd207
+       //TODO: PALIGNR $7, M3, M2              // 0f3a0fd307
+       //TODO: PALIGNR $7, (BX), M3            // 0f3a0f1b07
+       //TODO: PALIGNR $7, (R11), M3           // 410f3a0f1b07
+       //TODO: PALIGNR $7, M2, M3              // 0f3a0fda07
+       //TODO: PALIGNR $7, M3, M3              // 0f3a0fdb07
+       //TODO: PALIGNR $7, (BX), X2            // 660f3a0f1307
+       //TODO: PALIGNR $7, (R11), X2           // 66410f3a0f1307
+       //TODO: PALIGNR $7, X2, X2              // 660f3a0fd207
+       //TODO: PALIGNR $7, X11, X2             // 66410f3a0fd307
+       //TODO: PALIGNR $7, (BX), X11           // 66440f3a0f1b07
+       //TODO: PALIGNR $7, (R11), X11          // 66450f3a0f1b07
+       //TODO: PALIGNR $7, X2, X11             // 66440f3a0fda07
+       //TODO: PALIGNR $7, X11, X11            // 66450f3a0fdb07
+       PAND (BX), M2                           // 0fdb13
+       PAND (R11), M2                          // 410fdb13
+       PAND M2, M2                             // 0fdbd2
+       PAND M3, M2                             // 0fdbd3
+       PAND (BX), M3                           // 0fdb1b
+       PAND (R11), M3                          // 410fdb1b
+       PAND M2, M3                             // 0fdbda
+       PAND M3, M3                             // 0fdbdb
+       PAND (BX), X2                           // 660fdb13
+       PAND (R11), X2                          // 66410fdb13
+       PAND X2, X2                             // 660fdbd2
+       PAND X11, X2                            // 66410fdbd3
+       PAND (BX), X11                          // 66440fdb1b
+       PAND (R11), X11                         // 66450fdb1b
+       PAND X2, X11                            // 66440fdbda
+       PAND X11, X11                           // 66450fdbdb
+       PANDN (BX), M2                          // 0fdf13
+       PANDN (R11), M2                         // 410fdf13
+       PANDN M2, M2                            // 0fdfd2
+       PANDN M3, M2                            // 0fdfd3
+       PANDN (BX), M3                          // 0fdf1b
+       PANDN (R11), M3                         // 410fdf1b
+       PANDN M2, M3                            // 0fdfda
+       PANDN M3, M3                            // 0fdfdb
+       PANDN (BX), X2                          // 660fdf13
+       PANDN (R11), X2                         // 66410fdf13
+       PANDN X2, X2                            // 660fdfd2
+       PANDN X11, X2                           // 66410fdfd3
+       PANDN (BX), X11                         // 66440fdf1b
+       PANDN (R11), X11                        // 66450fdf1b
+       PANDN X2, X11                           // 66440fdfda
+       PANDN X11, X11                          // 66450fdfdb
+       PAVGB (BX), M2                          // 0fe013
+       PAVGB (R11), M2                         // 410fe013
+       PAVGB M2, M2                            // 0fe0d2
+       PAVGB M3, M2                            // 0fe0d3
+       PAVGB (BX), M3                          // 0fe01b
+       PAVGB (R11), M3                         // 410fe01b
+       PAVGB M2, M3                            // 0fe0da
+       PAVGB M3, M3                            // 0fe0db
+       PAVGB (BX), X2                          // 660fe013
+       PAVGB (R11), X2                         // 66410fe013
+       PAVGB X2, X2                            // 660fe0d2
+       PAVGB X11, X2                           // 66410fe0d3
+       PAVGB (BX), X11                         // 66440fe01b
+       PAVGB (R11), X11                        // 66450fe01b
+       PAVGB X2, X11                           // 66440fe0da
+       PAVGB X11, X11                          // 66450fe0db
+       PAVGW (BX), M2                          // 0fe313
+       PAVGW (R11), M2                         // 410fe313
+       PAVGW M2, M2                            // 0fe3d2
+       PAVGW M3, M2                            // 0fe3d3
+       PAVGW (BX), M3                          // 0fe31b
+       PAVGW (R11), M3                         // 410fe31b
+       PAVGW M2, M3                            // 0fe3da
+       PAVGW M3, M3                            // 0fe3db
+       PAVGW (BX), X2                          // 660fe313
+       PAVGW (R11), X2                         // 66410fe313
+       PAVGW X2, X2                            // 660fe3d2
+       PAVGW X11, X2                           // 66410fe3d3
+       PAVGW (BX), X11                         // 66440fe31b
+       PAVGW (R11), X11                        // 66450fe31b
+       PAVGW X2, X11                           // 66440fe3da
+       PAVGW X11, X11                          // 66450fe3db
+       //TODO: PBLENDVB XMM0, (BX), X2         // 660f381013
+       //TODO: PBLENDVB XMM0, (R11), X2        // 66410f381013
+       //TODO: PBLENDVB XMM0, X2, X2           // 660f3810d2
+       //TODO: PBLENDVB XMM0, X11, X2          // 66410f3810d3
+       //TODO: PBLENDVB XMM0, (BX), X11        // 66440f38101b
+       //TODO: PBLENDVB XMM0, (R11), X11       // 66450f38101b
+       //TODO: PBLENDVB XMM0, X2, X11          // 66440f3810da
+       //TODO: PBLENDVB XMM0, X11, X11         // 66450f3810db
+       //TODO: PBLENDW $7, (BX), X2            // 660f3a0e1307
+       //TODO: PBLENDW $7, (R11), X2           // 66410f3a0e1307
+       //TODO: PBLENDW $7, X2, X2              // 660f3a0ed207
+       //TODO: PBLENDW $7, X11, X2             // 66410f3a0ed307
+       //TODO: PBLENDW $7, (BX), X11           // 66440f3a0e1b07
+       //TODO: PBLENDW $7, (R11), X11          // 66450f3a0e1b07
+       //TODO: PBLENDW $7, X2, X11             // 66440f3a0eda07
+       //TODO: PBLENDW $7, X11, X11            // 66450f3a0edb07
+       PCLMULQDQ $7, (BX), X2                  // 660f3a441307
+       PCLMULQDQ $7, (R11), X2                 // 66410f3a441307
+       PCLMULQDQ $7, X2, X2                    // 660f3a44d207
+       PCLMULQDQ $7, X11, X2                   // 66410f3a44d307
+       PCLMULQDQ $7, (BX), X11                 // 66440f3a441b07
+       PCLMULQDQ $7, (R11), X11                // 66450f3a441b07
+       PCLMULQDQ $7, X2, X11                   // 66440f3a44da07
+       PCLMULQDQ $7, X11, X11                  // 66450f3a44db07
+       PCMPEQB (BX), M2                        // 0f7413
+       PCMPEQB (R11), M2                       // 410f7413
+       PCMPEQB M2, M2                          // 0f74d2
+       PCMPEQB M3, M2                          // 0f74d3
+       PCMPEQB (BX), M3                        // 0f741b
+       PCMPEQB (R11), M3                       // 410f741b
+       PCMPEQB M2, M3                          // 0f74da
+       PCMPEQB M3, M3                          // 0f74db
+       PCMPEQB (BX), X2                        // 660f7413
+       PCMPEQB (R11), X2                       // 66410f7413
+       PCMPEQB X2, X2                          // 660f74d2
+       PCMPEQB X11, X2                         // 66410f74d3
+       PCMPEQB (BX), X11                       // 66440f741b
+       PCMPEQB (R11), X11                      // 66450f741b
+       PCMPEQB X2, X11                         // 66440f74da
+       PCMPEQB X11, X11                        // 66450f74db
+       PCMPEQL (BX), M2                        // 0f7613
+       PCMPEQL (R11), M2                       // 410f7613
+       PCMPEQL M2, M2                          // 0f76d2
+       PCMPEQL M3, M2                          // 0f76d3
+       PCMPEQL (BX), M3                        // 0f761b
+       PCMPEQL (R11), M3                       // 410f761b
+       PCMPEQL M2, M3                          // 0f76da
+       PCMPEQL M3, M3                          // 0f76db
+       PCMPEQL (BX), X2                        // 660f7613
+       PCMPEQL (R11), X2                       // 66410f7613
+       PCMPEQL X2, X2                          // 660f76d2
+       PCMPEQL X11, X2                         // 66410f76d3
+       PCMPEQL (BX), X11                       // 66440f761b
+       PCMPEQL (R11), X11                      // 66450f761b
+       PCMPEQL X2, X11                         // 66440f76da
+       PCMPEQL X11, X11                        // 66450f76db
+       //TODO: PCMPEQQ (BX), X2                // 660f382913
+       //TODO: PCMPEQQ (R11), X2               // 66410f382913
+       //TODO: PCMPEQQ X2, X2                  // 660f3829d2
+       //TODO: PCMPEQQ X11, X2                 // 66410f3829d3
+       //TODO: PCMPEQQ (BX), X11               // 66440f38291b
+       //TODO: PCMPEQQ (R11), X11              // 66450f38291b
+       //TODO: PCMPEQQ X2, X11                 // 66440f3829da
+       //TODO: PCMPEQQ X11, X11                // 66450f3829db
+       PCMPEQW (BX), M2                        // 0f7513
+       PCMPEQW (R11), M2                       // 410f7513
+       PCMPEQW M2, M2                          // 0f75d2
+       PCMPEQW M3, M2                          // 0f75d3
+       PCMPEQW (BX), M3                        // 0f751b
+       PCMPEQW (R11), M3                       // 410f751b
+       PCMPEQW M2, M3                          // 0f75da
+       PCMPEQW M3, M3                          // 0f75db
+       PCMPEQW (BX), X2                        // 660f7513
+       PCMPEQW (R11), X2                       // 66410f7513
+       PCMPEQW X2, X2                          // 660f75d2
+       PCMPEQW X11, X2                         // 66410f75d3
+       PCMPEQW (BX), X11                       // 66440f751b
+       PCMPEQW (R11), X11                      // 66450f751b
+       PCMPEQW X2, X11                         // 66440f75da
+       PCMPEQW X11, X11                        // 66450f75db
+       //TODO: PCMPESTRI $7, (BX), X2          // 660f3a611307
+       //TODO: PCMPESTRI $7, (R11), X2         // 66410f3a611307
+       //TODO: PCMPESTRI $7, X2, X2            // 660f3a61d207
+       //TODO: PCMPESTRI $7, X11, X2           // 66410f3a61d307
+       //TODO: PCMPESTRI $7, (BX), X11         // 66440f3a611b07
+       //TODO: PCMPESTRI $7, (R11), X11        // 66450f3a611b07
+       //TODO: PCMPESTRI $7, X2, X11           // 66440f3a61da07
+       //TODO: PCMPESTRI $7, X11, X11          // 66450f3a61db07
+       //TODO: PCMPESTRM $7, (BX), X2          // 660f3a601307
+       //TODO: PCMPESTRM $7, (R11), X2         // 66410f3a601307
+       //TODO: PCMPESTRM $7, X2, X2            // 660f3a60d207
+       //TODO: PCMPESTRM $7, X11, X2           // 66410f3a60d307
+       //TODO: PCMPESTRM $7, (BX), X11         // 66440f3a601b07
+       //TODO: PCMPESTRM $7, (R11), X11        // 66450f3a601b07
+       //TODO: PCMPESTRM $7, X2, X11           // 66440f3a60da07
+       //TODO: PCMPESTRM $7, X11, X11          // 66450f3a60db07
+       PCMPGTB (BX), M2                        // 0f6413
+       PCMPGTB (R11), M2                       // 410f6413
+       PCMPGTB M2, M2                          // 0f64d2
+       PCMPGTB M3, M2                          // 0f64d3
+       PCMPGTB (BX), M3                        // 0f641b
+       PCMPGTB (R11), M3                       // 410f641b
+       PCMPGTB M2, M3                          // 0f64da
+       PCMPGTB M3, M3                          // 0f64db
+       PCMPGTB (BX), X2                        // 660f6413
+       PCMPGTB (R11), X2                       // 66410f6413
+       PCMPGTB X2, X2                          // 660f64d2
+       PCMPGTB X11, X2                         // 66410f64d3
+       PCMPGTB (BX), X11                       // 66440f641b
+       PCMPGTB (R11), X11                      // 66450f641b
+       PCMPGTB X2, X11                         // 66440f64da
+       PCMPGTB X11, X11                        // 66450f64db
+       PCMPGTL (BX), M2                        // 0f6613
+       PCMPGTL (R11), M2                       // 410f6613
+       PCMPGTL M2, M2                          // 0f66d2
+       PCMPGTL M3, M2                          // 0f66d3
+       PCMPGTL (BX), M3                        // 0f661b
+       PCMPGTL (R11), M3                       // 410f661b
+       PCMPGTL M2, M3                          // 0f66da
+       PCMPGTL M3, M3                          // 0f66db
+       PCMPGTL (BX), X2                        // 660f6613
+       PCMPGTL (R11), X2                       // 66410f6613
+       PCMPGTL X2, X2                          // 660f66d2
+       PCMPGTL X11, X2                         // 66410f66d3
+       PCMPGTL (BX), X11                       // 66440f661b
+       PCMPGTL (R11), X11                      // 66450f661b
+       PCMPGTL X2, X11                         // 66440f66da
+       PCMPGTL X11, X11                        // 66450f66db
+       //TODO: PCMPGTQ (BX), X2                // 660f383713
+       //TODO: PCMPGTQ (R11), X2               // 66410f383713
+       //TODO: PCMPGTQ X2, X2                  // 660f3837d2
+       //TODO: PCMPGTQ X11, X2                 // 66410f3837d3
+       //TODO: PCMPGTQ (BX), X11               // 66440f38371b
+       //TODO: PCMPGTQ (R11), X11              // 66450f38371b
+       //TODO: PCMPGTQ X2, X11                 // 66440f3837da
+       //TODO: PCMPGTQ X11, X11                // 66450f3837db
+       PCMPGTW (BX), M2                        // 0f6513
+       PCMPGTW (R11), M2                       // 410f6513
+       PCMPGTW M2, M2                          // 0f65d2
+       PCMPGTW M3, M2                          // 0f65d3
+       PCMPGTW (BX), M3                        // 0f651b
+       PCMPGTW (R11), M3                       // 410f651b
+       PCMPGTW M2, M3                          // 0f65da
+       PCMPGTW M3, M3                          // 0f65db
+       PCMPGTW (BX), X2                        // 660f6513
+       PCMPGTW (R11), X2                       // 66410f6513
+       PCMPGTW X2, X2                          // 660f65d2
+       PCMPGTW X11, X2                         // 66410f65d3
+       PCMPGTW (BX), X11                       // 66440f651b
+       PCMPGTW (R11), X11                      // 66450f651b
+       PCMPGTW X2, X11                         // 66440f65da
+       PCMPGTW X11, X11                        // 66450f65db
+       //TODO: PCMPISTRI $7, (BX), X2          // 660f3a631307
+       //TODO: PCMPISTRI $7, (R11), X2         // 66410f3a631307
+       //TODO: PCMPISTRI $7, X2, X2            // 660f3a63d207
+       //TODO: PCMPISTRI $7, X11, X2           // 66410f3a63d307
+       //TODO: PCMPISTRI $7, (BX), X11         // 66440f3a631b07
+       //TODO: PCMPISTRI $7, (R11), X11        // 66450f3a631b07
+       //TODO: PCMPISTRI $7, X2, X11           // 66440f3a63da07
+       //TODO: PCMPISTRI $7, X11, X11          // 66450f3a63db07
+       //TODO: PCMPISTRM $7, (BX), X2          // 660f3a621307
+       //TODO: PCMPISTRM $7, (R11), X2         // 66410f3a621307
+       //TODO: PCMPISTRM $7, X2, X2            // 660f3a62d207
+       //TODO: PCMPISTRM $7, X11, X2           // 66410f3a62d307
+       //TODO: PCMPISTRM $7, (BX), X11         // 66440f3a621b07
+       //TODO: PCMPISTRM $7, (R11), X11        // 66450f3a621b07
+       //TODO: PCMPISTRM $7, X2, X11           // 66440f3a62da07
+       //TODO: PCMPISTRM $7, X11, X11          // 66450f3a62db07
+       PDEPL (BX), R9, DX                      // c4e233f513
+       PDEPL (R11), R9, DX                     // c4c233f513
+       PDEPL DX, R9, DX                        // c4e233f5d2
+       PDEPL R11, R9, DX                       // c4c233f5d3
+       PDEPL (BX), R9, R11                     // c46233f51b
+       PDEPL (R11), R9, R11                    // c44233f51b
+       PDEPL DX, R9, R11                       // c46233f5da
+       PDEPL R11, R9, R11                      // c44233f5db
+       PDEPQ (BX), R14, DX                     // c4e28bf513
+       PDEPQ (R11), R14, DX                    // c4c28bf513
+       PDEPQ DX, R14, DX                       // c4e28bf5d2
+       PDEPQ R11, R14, DX                      // c4c28bf5d3
+       PDEPQ (BX), R14, R11                    // c4628bf51b
+       PDEPQ (R11), R14, R11                   // c4428bf51b
+       PDEPQ DX, R14, R11                      // c4628bf5da
+       PDEPQ R11, R14, R11                     // c4428bf5db
+       PEXTL (BX), R9, DX                      // c4e232f513
+       PEXTL (R11), R9, DX                     // c4c232f513
+       PEXTL DX, R9, DX                        // c4e232f5d2
+       PEXTL R11, R9, DX                       // c4c232f5d3
+       PEXTL (BX), R9, R11                     // c46232f51b
+       PEXTL (R11), R9, R11                    // c44232f51b
+       PEXTL DX, R9, R11                       // c46232f5da
+       PEXTL R11, R9, R11                      // c44232f5db
+       PEXTQ (BX), R14, DX                     // c4e28af513
+       PEXTQ (R11), R14, DX                    // c4c28af513
+       PEXTQ DX, R14, DX                       // c4e28af5d2
+       PEXTQ R11, R14, DX                      // c4c28af5d3
+       PEXTQ (BX), R14, R11                    // c4628af51b
+       PEXTQ (R11), R14, R11                   // c4428af51b
+       PEXTQ DX, R14, R11                      // c4628af5da
+       PEXTQ R11, R14, R11                     // c4428af5db
+       PEXTRB $7, X2, (BX)                     // 660f3a141307
+       PEXTRB $7, X11, (BX)                    // 66440f3a141b07
+       PEXTRB $7, X2, (R11)                    // 66410f3a141307
+       PEXTRB $7, X11, (R11)                   // 66450f3a141b07
+       PEXTRB $7, X2, DX                       // 660f3a14d207
+       PEXTRB $7, X11, DX                      // 66440f3a14da07
+       PEXTRB $7, X2, R11                      // 66410f3a14d307
+       PEXTRB $7, X11, R11                     // 66450f3a14db07
+       PEXTRD $7, X2, (BX)                     // 660f3a161307
+       PEXTRD $7, X11, (BX)                    // 66440f3a161b07
+       PEXTRD $7, X2, (R11)                    // 66410f3a161307
+       PEXTRD $7, X11, (R11)                   // 66450f3a161b07
+       PEXTRD $7, X2, DX                       // 660f3a16d207
+       PEXTRD $7, X11, DX                      // 66440f3a16da07
+       PEXTRD $7, X2, R11                      // 66410f3a16d307
+       PEXTRD $7, X11, R11                     // 66450f3a16db07
+       PEXTRQ $7, X2, (BX)                     // 66480f3a161307
+       PEXTRQ $7, X11, (BX)                    // 664c0f3a161b07
+       PEXTRQ $7, X2, (R11)                    // 66490f3a161307
+       PEXTRQ $7, X11, (R11)                   // 664d0f3a161b07
+       PEXTRQ $7, X2, DX                       // 66480f3a16d207
+       PEXTRQ $7, X11, DX                      // 664c0f3a16da07
+       PEXTRQ $7, X2, R11                      // 66490f3a16d307
+       PEXTRQ $7, X11, R11                     // 664d0f3a16db07
+       //TODO: PEXTRW $7, M2, DX               // 0fc5d207
+       //TODO: PEXTRW $7, M3, DX               // 0fc5d307
+       //TODO: PEXTRW $7, M2, R11              // 440fc5da07
+       //TODO: PEXTRW $7, M3, R11              // 440fc5db07
+       PEXTRW $7, X2, DX                       // 660fc5d207 or 660f3a15d207
+       PEXTRW $7, X11, DX                      // 66410fc5d307 or 66440f3a15da07
+       PEXTRW $7, X2, R11                      // 66440fc5da07 or 66410f3a15d307
+       PEXTRW $7, X11, R11                     // 66450fc5db07 or 66450f3a15db07
+       //TODO: PEXTRW $7, X2, (BX)             // 660f3a151307
+       //TODO: PEXTRW $7, X11, (BX)            // 66440f3a151b07
+       //TODO: PEXTRW $7, X2, (R11)            // 66410f3a151307
+       //TODO: PEXTRW $7, X11, (R11)           // 66450f3a151b07
+       PHADDD (BX), M2                         // 0f380213
+       PHADDD (R11), M2                        // 410f380213
+       PHADDD M2, M2                           // 0f3802d2
+       PHADDD M3, M2                           // 0f3802d3
+       PHADDD (BX), M3                         // 0f38021b
+       PHADDD (R11), M3                        // 410f38021b
+       PHADDD M2, M3                           // 0f3802da
+       PHADDD M3, M3                           // 0f3802db
+       PHADDD (BX), X2                         // 660f380213
+       PHADDD (R11), X2                        // 66410f380213
+       PHADDD X2, X2                           // 660f3802d2
+       PHADDD X11, X2                          // 66410f3802d3
+       PHADDD (BX), X11                        // 66440f38021b
+       PHADDD (R11), X11                       // 66450f38021b
+       PHADDD X2, X11                          // 66440f3802da
+       PHADDD X11, X11                         // 66450f3802db
+       //TODO: PHADDSW (BX), M2                // 0f380313
+       //TODO: PHADDSW (R11), M2               // 410f380313
+       //TODO: PHADDSW M2, M2                  // 0f3803d2
+       //TODO: PHADDSW M3, M2                  // 0f3803d3
+       //TODO: PHADDSW (BX), M3                // 0f38031b
+       //TODO: PHADDSW (R11), M3               // 410f38031b
+       //TODO: PHADDSW M2, M3                  // 0f3803da
+       //TODO: PHADDSW M3, M3                  // 0f3803db
+       //TODO: PHADDSW (BX), X2                // 660f380313
+       //TODO: PHADDSW (R11), X2               // 66410f380313
+       //TODO: PHADDSW X2, X2                  // 660f3803d2
+       //TODO: PHADDSW X11, X2                 // 66410f3803d3
+       //TODO: PHADDSW (BX), X11               // 66440f38031b
+       //TODO: PHADDSW (R11), X11              // 66450f38031b
+       //TODO: PHADDSW X2, X11                 // 66440f3803da
+       //TODO: PHADDSW X11, X11                // 66450f3803db
+       //TODO: PHADDW (BX), M2                 // 0f380113
+       //TODO: PHADDW (R11), M2                // 410f380113
+       //TODO: PHADDW M2, M2                   // 0f3801d2
+       //TODO: PHADDW M3, M2                   // 0f3801d3
+       //TODO: PHADDW (BX), M3                 // 0f38011b
+       //TODO: PHADDW (R11), M3                // 410f38011b
+       //TODO: PHADDW M2, M3                   // 0f3801da
+       //TODO: PHADDW M3, M3                   // 0f3801db
+       //TODO: PHADDW (BX), X2                 // 660f380113
+       //TODO: PHADDW (R11), X2                // 66410f380113
+       //TODO: PHADDW X2, X2                   // 660f3801d2
+       //TODO: PHADDW X11, X2                  // 66410f3801d3
+       //TODO: PHADDW (BX), X11                // 66440f38011b
+       //TODO: PHADDW (R11), X11               // 66450f38011b
+       //TODO: PHADDW X2, X11                  // 66440f3801da
+       //TODO: PHADDW X11, X11                 // 66450f3801db
+       //TODO: PHMINPOSUW (BX), X2             // 660f384113
+       //TODO: PHMINPOSUW (R11), X2            // 66410f384113
+       //TODO: PHMINPOSUW X2, X2               // 660f3841d2
+       //TODO: PHMINPOSUW X11, X2              // 66410f3841d3
+       //TODO: PHMINPOSUW (BX), X11            // 66440f38411b
+       //TODO: PHMINPOSUW (R11), X11           // 66450f38411b
+       //TODO: PHMINPOSUW X2, X11              // 66440f3841da
+       //TODO: PHMINPOSUW X11, X11             // 66450f3841db
+       //TODO: PHSUBD (BX), M2                 // 0f380613
+       //TODO: PHSUBD (R11), M2                // 410f380613
+       //TODO: PHSUBD M2, M2                   // 0f3806d2
+       //TODO: PHSUBD M3, M2                   // 0f3806d3
+       //TODO: PHSUBD (BX), M3                 // 0f38061b
+       //TODO: PHSUBD (R11), M3                // 410f38061b
+       //TODO: PHSUBD M2, M3                   // 0f3806da
+       //TODO: PHSUBD M3, M3                   // 0f3806db
+       //TODO: PHSUBD (BX), X2                 // 660f380613
+       //TODO: PHSUBD (R11), X2                // 66410f380613
+       //TODO: PHSUBD X2, X2                   // 660f3806d2
+       //TODO: PHSUBD X11, X2                  // 66410f3806d3
+       //TODO: PHSUBD (BX), X11                // 66440f38061b
+       //TODO: PHSUBD (R11), X11               // 66450f38061b
+       //TODO: PHSUBD X2, X11                  // 66440f3806da
+       //TODO: PHSUBD X11, X11                 // 66450f3806db
+       //TODO: PHSUBSW (BX), M2                // 0f380713
+       //TODO: PHSUBSW (R11), M2               // 410f380713
+       //TODO: PHSUBSW M2, M2                  // 0f3807d2
+       //TODO: PHSUBSW M3, M2                  // 0f3807d3
+       //TODO: PHSUBSW (BX), M3                // 0f38071b
+       //TODO: PHSUBSW (R11), M3               // 410f38071b
+       //TODO: PHSUBSW M2, M3                  // 0f3807da
+       //TODO: PHSUBSW M3, M3                  // 0f3807db
+       //TODO: PHSUBSW (BX), X2                // 660f380713
+       //TODO: PHSUBSW (R11), X2               // 66410f380713
+       //TODO: PHSUBSW X2, X2                  // 660f3807d2
+       //TODO: PHSUBSW X11, X2                 // 66410f3807d3
+       //TODO: PHSUBSW (BX), X11               // 66440f38071b
+       //TODO: PHSUBSW (R11), X11              // 66450f38071b
+       //TODO: PHSUBSW X2, X11                 // 66440f3807da
+       //TODO: PHSUBSW X11, X11                // 66450f3807db
+       //TODO: PHSUBW (BX), M2                 // 0f380513
+       //TODO: PHSUBW (R11), M2                // 410f380513
+       //TODO: PHSUBW M2, M2                   // 0f3805d2
+       //TODO: PHSUBW M3, M2                   // 0f3805d3
+       //TODO: PHSUBW (BX), M3                 // 0f38051b
+       //TODO: PHSUBW (R11), M3                // 410f38051b
+       //TODO: PHSUBW M2, M3                   // 0f3805da
+       //TODO: PHSUBW M3, M3                   // 0f3805db
+       //TODO: PHSUBW (BX), X2                 // 660f380513
+       //TODO: PHSUBW (R11), X2                // 66410f380513
+       //TODO: PHSUBW X2, X2                   // 660f3805d2
+       //TODO: PHSUBW X11, X2                  // 66410f3805d3
+       //TODO: PHSUBW (BX), X11                // 66440f38051b
+       //TODO: PHSUBW (R11), X11               // 66450f38051b
+       //TODO: PHSUBW X2, X11                  // 66440f3805da
+       //TODO: PHSUBW X11, X11                 // 66450f3805db
+       PINSRB $7, (BX), X2                     // 660f3a201307
+       PINSRB $7, (R11), X2                    // 66410f3a201307
+       PINSRB $7, DX, X2                       // 660f3a20d207
+       PINSRB $7, R11, X2                      // 66410f3a20d307
+       PINSRB $7, (BX), X11                    // 66440f3a201b07
+       PINSRB $7, (R11), X11                   // 66450f3a201b07
+       PINSRB $7, DX, X11                      // 66440f3a20da07
+       PINSRB $7, R11, X11                     // 66450f3a20db07
+       PINSRD $7, (BX), X2                     // 660f3a221307
+       PINSRD $7, (R11), X2                    // 66410f3a221307
+       PINSRD $7, DX, X2                       // 660f3a22d207
+       PINSRD $7, R11, X2                      // 66410f3a22d307
+       PINSRD $7, (BX), X11                    // 66440f3a221b07
+       PINSRD $7, (R11), X11                   // 66450f3a221b07
+       PINSRD $7, DX, X11                      // 66440f3a22da07
+       PINSRD $7, R11, X11                     // 66450f3a22db07
+       PINSRQ $7, (BX), X2                     // 66480f3a221307
+       PINSRQ $7, (R11), X2                    // 66490f3a221307
+       PINSRQ $7, DX, X2                       // 66480f3a22d207
+       PINSRQ $7, R11, X2                      // 66490f3a22d307
+       PINSRQ $7, (BX), X11                    // 664c0f3a221b07
+       PINSRQ $7, (R11), X11                   // 664d0f3a221b07
+       PINSRQ $7, DX, X11                      // 664c0f3a22da07
+       PINSRQ $7, R11, X11                     // 664d0f3a22db07
+       //TODO: PINSRW $7, (BX), M2             // 0fc41307
+       //TODO: PINSRW $7, (R11), M2            // 410fc41307
+       //TODO: PINSRW $7, DX, M2               // 0fc4d207
+       //TODO: PINSRW $7, R11, M2              // 410fc4d307
+       //TODO: PINSRW $7, (BX), M3             // 0fc41b07
+       //TODO: PINSRW $7, (R11), M3            // 410fc41b07
+       //TODO: PINSRW $7, DX, M3               // 0fc4da07
+       //TODO: PINSRW $7, R11, M3              // 410fc4db07
+       PINSRW $7, (BX), X2                     // 660fc41307
+       PINSRW $7, (R11), X2                    // 66410fc41307
+       PINSRW $7, DX, X2                       // 660fc4d207
+       PINSRW $7, R11, X2                      // 66410fc4d307
+       PINSRW $7, (BX), X11                    // 66440fc41b07
+       PINSRW $7, (R11), X11                   // 66450fc41b07
+       PINSRW $7, DX, X11                      // 66440fc4da07
+       PINSRW $7, R11, X11                     // 66450fc4db07
+       //TODO: PMADDUBSW (BX), M2              // 0f380413
+       //TODO: PMADDUBSW (R11), M2             // 410f380413
+       //TODO: PMADDUBSW M2, M2                // 0f3804d2
+       //TODO: PMADDUBSW M3, M2                // 0f3804d3
+       //TODO: PMADDUBSW (BX), M3              // 0f38041b
+       //TODO: PMADDUBSW (R11), M3             // 410f38041b
+       //TODO: PMADDUBSW M2, M3                // 0f3804da
+       //TODO: PMADDUBSW M3, M3                // 0f3804db
+       //TODO: PMADDUBSW (BX), X2              // 660f380413
+       //TODO: PMADDUBSW (R11), X2             // 66410f380413
+       //TODO: PMADDUBSW X2, X2                // 660f3804d2
+       //TODO: PMADDUBSW X11, X2               // 66410f3804d3
+       //TODO: PMADDUBSW (BX), X11             // 66440f38041b
+       //TODO: PMADDUBSW (R11), X11            // 66450f38041b
+       //TODO: PMADDUBSW X2, X11               // 66440f3804da
+       //TODO: PMADDUBSW X11, X11              // 66450f3804db
+       PMADDWL (BX), M2                        // 0ff513
+       PMADDWL (R11), M2                       // 410ff513
+       PMADDWL M2, M2                          // 0ff5d2
+       PMADDWL M3, M2                          // 0ff5d3
+       PMADDWL (BX), M3                        // 0ff51b
+       PMADDWL (R11), M3                       // 410ff51b
+       PMADDWL M2, M3                          // 0ff5da
+       PMADDWL M3, M3                          // 0ff5db
+       PMADDWL (BX), X2                        // 660ff513
+       PMADDWL (R11), X2                       // 66410ff513
+       PMADDWL X2, X2                          // 660ff5d2
+       PMADDWL X11, X2                         // 66410ff5d3
+       PMADDWL (BX), X11                       // 66440ff51b
+       PMADDWL (R11), X11                      // 66450ff51b
+       PMADDWL X2, X11                         // 66440ff5da
+       PMADDWL X11, X11                        // 66450ff5db
+       //TODO: PMAXSB (BX), X2                 // 660f383c13
+       //TODO: PMAXSB (R11), X2                // 66410f383c13
+       //TODO: PMAXSB X2, X2                   // 660f383cd2
+       //TODO: PMAXSB X11, X2                  // 66410f383cd3
+       //TODO: PMAXSB (BX), X11                // 66440f383c1b
+       //TODO: PMAXSB (R11), X11               // 66450f383c1b
+       //TODO: PMAXSB X2, X11                  // 66440f383cda
+       //TODO: PMAXSB X11, X11                 // 66450f383cdb
+       //TODO: PMAXSD (BX), X2                 // 660f383d13
+       //TODO: PMAXSD (R11), X2                // 66410f383d13
+       //TODO: PMAXSD X2, X2                   // 660f383dd2
+       //TODO: PMAXSD X11, X2                  // 66410f383dd3
+       //TODO: PMAXSD (BX), X11                // 66440f383d1b
+       //TODO: PMAXSD (R11), X11               // 66450f383d1b
+       //TODO: PMAXSD X2, X11                  // 66440f383dda
+       //TODO: PMAXSD X11, X11                 // 66450f383ddb
+       //TODO: PMAXSW (BX), M2                 // 0fee13
+       //TODO: PMAXSW (R11), M2                // 410fee13
+       //TODO: PMAXSW M2, M2                   // 0feed2
+       //TODO: PMAXSW M3, M2                   // 0feed3
+       //TODO: PMAXSW (BX), M3                 // 0fee1b
+       //TODO: PMAXSW (R11), M3                // 410fee1b
+       //TODO: PMAXSW M2, M3                   // 0feeda
+       //TODO: PMAXSW M3, M3                   // 0feedb
+       PMAXSW (BX), X2                         // 660fee13
+       PMAXSW (R11), X2                        // 66410fee13
+       PMAXSW X2, X2                           // 660feed2
+       PMAXSW X11, X2                          // 66410feed3
+       PMAXSW (BX), X11                        // 66440fee1b
+       PMAXSW (R11), X11                       // 66450fee1b
+       PMAXSW X2, X11                          // 66440feeda
+       PMAXSW X11, X11                         // 66450feedb
+       //TODO: PMAXUB (BX), M2                 // 0fde13
+       //TODO: PMAXUB (R11), M2                // 410fde13
+       //TODO: PMAXUB M2, M2                   // 0fded2
+       //TODO: PMAXUB M3, M2                   // 0fded3
+       //TODO: PMAXUB (BX), M3                 // 0fde1b
+       //TODO: PMAXUB (R11), M3                // 410fde1b
+       //TODO: PMAXUB M2, M3                   // 0fdeda
+       //TODO: PMAXUB M3, M3                   // 0fdedb
+       PMAXUB (BX), X2                         // 660fde13
+       PMAXUB (R11), X2                        // 66410fde13
+       PMAXUB X2, X2                           // 660fded2
+       PMAXUB X11, X2                          // 66410fded3
+       PMAXUB (BX), X11                        // 66440fde1b
+       PMAXUB (R11), X11                       // 66450fde1b
+       PMAXUB X2, X11                          // 66440fdeda
+       PMAXUB X11, X11                         // 66450fdedb
+       //TODO: PMAXUD (BX), X2                 // 660f383f13
+       //TODO: PMAXUD (R11), X2                // 66410f383f13
+       //TODO: PMAXUD X2, X2                   // 660f383fd2
+       //TODO: PMAXUD X11, X2                  // 66410f383fd3
+       //TODO: PMAXUD (BX), X11                // 66440f383f1b
+       //TODO: PMAXUD (R11), X11               // 66450f383f1b
+       //TODO: PMAXUD X2, X11                  // 66440f383fda
+       //TODO: PMAXUD X11, X11                 // 66450f383fdb
+       //TODO: PMAXUW (BX), X2                 // 660f383e13
+       //TODO: PMAXUW (R11), X2                // 66410f383e13
+       //TODO: PMAXUW X2, X2                   // 660f383ed2
+       //TODO: PMAXUW X11, X2                  // 66410f383ed3
+       //TODO: PMAXUW (BX), X11                // 66440f383e1b
+       //TODO: PMAXUW (R11), X11               // 66450f383e1b
+       //TODO: PMAXUW X2, X11                  // 66440f383eda
+       //TODO: PMAXUW X11, X11                 // 66450f383edb
+       //TODO: PMINSB (BX), X2                 // 660f383813
+       //TODO: PMINSB (R11), X2                // 66410f383813
+       //TODO: PMINSB X2, X2                   // 660f3838d2
+       //TODO: PMINSB X11, X2                  // 66410f3838d3
+       //TODO: PMINSB (BX), X11                // 66440f38381b
+       //TODO: PMINSB (R11), X11               // 66450f38381b
+       //TODO: PMINSB X2, X11                  // 66440f3838da
+       //TODO: PMINSB X11, X11                 // 66450f3838db
+       //TODO: PMINSD (BX), X2                 // 660f383913
+       //TODO: PMINSD (R11), X2                // 66410f383913
+       //TODO: PMINSD X2, X2                   // 660f3839d2
+       //TODO: PMINSD X11, X2                  // 66410f3839d3
+       //TODO: PMINSD (BX), X11                // 66440f38391b
+       //TODO: PMINSD (R11), X11               // 66450f38391b
+       //TODO: PMINSD X2, X11                  // 66440f3839da
+       //TODO: PMINSD X11, X11                 // 66450f3839db
+       //TODO: PMINSW (BX), M2                 // 0fea13
+       //TODO: PMINSW (R11), M2                // 410fea13
+       //TODO: PMINSW M2, M2                   // 0fead2
+       //TODO: PMINSW M3, M2                   // 0fead3
+       //TODO: PMINSW (BX), M3                 // 0fea1b
+       //TODO: PMINSW (R11), M3                // 410fea1b
+       //TODO: PMINSW M2, M3                   // 0feada
+       //TODO: PMINSW M3, M3                   // 0feadb
+       PMINSW (BX), X2                         // 660fea13
+       PMINSW (R11), X2                        // 66410fea13
+       PMINSW X2, X2                           // 660fead2
+       PMINSW X11, X2                          // 66410fead3
+       PMINSW (BX), X11                        // 66440fea1b
+       PMINSW (R11), X11                       // 66450fea1b
+       PMINSW X2, X11                          // 66440feada
+       PMINSW X11, X11                         // 66450feadb
+       //TODO: PMINUB (BX), M2                 // 0fda13
+       //TODO: PMINUB (R11), M2                // 410fda13
+       //TODO: PMINUB M2, M2                   // 0fdad2
+       //TODO: PMINUB M3, M2                   // 0fdad3
+       //TODO: PMINUB (BX), M3                 // 0fda1b
+       //TODO: PMINUB (R11), M3                // 410fda1b
+       //TODO: PMINUB M2, M3                   // 0fdada
+       //TODO: PMINUB M3, M3                   // 0fdadb
+       PMINUB (BX), X2                         // 660fda13
+       PMINUB (R11), X2                        // 66410fda13
+       PMINUB X2, X2                           // 660fdad2
+       PMINUB X11, X2                          // 66410fdad3
+       PMINUB (BX), X11                        // 66440fda1b
+       PMINUB (R11), X11                       // 66450fda1b
+       PMINUB X2, X11                          // 66440fdada
+       PMINUB X11, X11                         // 66450fdadb
+       //TODO: PMINUD (BX), X2                 // 660f383b13
+       //TODO: PMINUD (R11), X2                // 66410f383b13
+       //TODO: PMINUD X2, X2                   // 660f383bd2
+       //TODO: PMINUD X11, X2                  // 66410f383bd3
+       //TODO: PMINUD (BX), X11                // 66440f383b1b
+       //TODO: PMINUD (R11), X11               // 66450f383b1b
+       //TODO: PMINUD X2, X11                  // 66440f383bda
+       //TODO: PMINUD X11, X11                 // 66450f383bdb
+       //TODO: PMINUW (BX), X2                 // 660f383a13
+       //TODO: PMINUW (R11), X2                // 66410f383a13
+       //TODO: PMINUW X2, X2                   // 660f383ad2
+       //TODO: PMINUW X11, X2                  // 66410f383ad3
+       //TODO: PMINUW (BX), X11                // 66440f383a1b
+       //TODO: PMINUW (R11), X11               // 66450f383a1b
+       //TODO: PMINUW X2, X11                  // 66440f383ada
+       //TODO: PMINUW X11, X11                 // 66450f383adb
+       PMOVMSKB M2, DX                         // 0fd7d2
+       PMOVMSKB M3, DX                         // 0fd7d3
+       PMOVMSKB M2, R11                        // 440fd7da
+       PMOVMSKB M3, R11                        // 440fd7db
+       PMOVMSKB X2, DX                         // 660fd7d2
+       PMOVMSKB X11, DX                        // 66410fd7d3
+       PMOVMSKB X2, R11                        // 66440fd7da
+       PMOVMSKB X11, R11                       // 66450fd7db
+       PMOVSXBD (BX), X2                       // 660f382113
+       PMOVSXBD (R11), X2                      // 66410f382113
+       PMOVSXBD X2, X2                         // 660f3821d2
+       PMOVSXBD X11, X2                        // 66410f3821d3
+       PMOVSXBD (BX), X11                      // 66440f38211b
+       PMOVSXBD (R11), X11                     // 66450f38211b
+       PMOVSXBD X2, X11                        // 66440f3821da
+       PMOVSXBD X11, X11                       // 66450f3821db
+       PMOVSXBQ (BX), X2                       // 660f382213
+       PMOVSXBQ (R11), X2                      // 66410f382213
+       PMOVSXBQ X2, X2                         // 660f3822d2
+       PMOVSXBQ X11, X2                        // 66410f3822d3
+       PMOVSXBQ (BX), X11                      // 66440f38221b
+       PMOVSXBQ (R11), X11                     // 66450f38221b
+       PMOVSXBQ X2, X11                        // 66440f3822da
+       PMOVSXBQ X11, X11                       // 66450f3822db
+       PMOVSXBW (BX), X2                       // 660f382013
+       PMOVSXBW (R11), X2                      // 66410f382013
+       PMOVSXBW X2, X2                         // 660f3820d2
+       PMOVSXBW X11, X2                        // 66410f3820d3
+       PMOVSXBW (BX), X11                      // 66440f38201b
+       PMOVSXBW (R11), X11                     // 66450f38201b
+       PMOVSXBW X2, X11                        // 66440f3820da
+       PMOVSXBW X11, X11                       // 66450f3820db
+       PMOVSXDQ (BX), X2                       // 660f382513
+       PMOVSXDQ (R11), X2                      // 66410f382513
+       PMOVSXDQ X2, X2                         // 660f3825d2
+       PMOVSXDQ X11, X2                        // 66410f3825d3
+       PMOVSXDQ (BX), X11                      // 66440f38251b
+       PMOVSXDQ (R11), X11                     // 66450f38251b
+       PMOVSXDQ X2, X11                        // 66440f3825da
+       PMOVSXDQ X11, X11                       // 66450f3825db
+       PMOVSXWD (BX), X2                       // 660f382313
+       PMOVSXWD (R11), X2                      // 66410f382313
+       PMOVSXWD X2, X2                         // 660f3823d2
+       PMOVSXWD X11, X2                        // 66410f3823d3
+       PMOVSXWD (BX), X11                      // 66440f38231b
+       PMOVSXWD (R11), X11                     // 66450f38231b
+       PMOVSXWD X2, X11                        // 66440f3823da
+       PMOVSXWD X11, X11                       // 66450f3823db
+       PMOVSXWQ (BX), X2                       // 660f382413
+       PMOVSXWQ (R11), X2                      // 66410f382413
+       PMOVSXWQ X2, X2                         // 660f3824d2
+       PMOVSXWQ X11, X2                        // 66410f3824d3
+       PMOVSXWQ (BX), X11                      // 66440f38241b
+       PMOVSXWQ (R11), X11                     // 66450f38241b
+       PMOVSXWQ X2, X11                        // 66440f3824da
+       PMOVSXWQ X11, X11                       // 66450f3824db
+       PMOVZXBD (BX), X2                       // 660f383113
+       PMOVZXBD (R11), X2                      // 66410f383113
+       PMOVZXBD X2, X2                         // 660f3831d2
+       PMOVZXBD X11, X2                        // 66410f3831d3
+       PMOVZXBD (BX), X11                      // 66440f38311b
+       PMOVZXBD (R11), X11                     // 66450f38311b
+       PMOVZXBD X2, X11                        // 66440f3831da
+       PMOVZXBD X11, X11                       // 66450f3831db
+       PMOVZXBQ (BX), X2                       // 660f383213
+       PMOVZXBQ (R11), X2                      // 66410f383213
+       PMOVZXBQ X2, X2                         // 660f3832d2
+       PMOVZXBQ X11, X2                        // 66410f3832d3
+       PMOVZXBQ (BX), X11                      // 66440f38321b
+       PMOVZXBQ (R11), X11                     // 66450f38321b
+       PMOVZXBQ X2, X11                        // 66440f3832da
+       PMOVZXBQ X11, X11                       // 66450f3832db
+       PMOVZXBW (BX), X2                       // 660f383013
+       PMOVZXBW (R11), X2                      // 66410f383013
+       PMOVZXBW X2, X2                         // 660f3830d2
+       PMOVZXBW X11, X2                        // 66410f3830d3
+       PMOVZXBW (BX), X11                      // 66440f38301b
+       PMOVZXBW (R11), X11                     // 66450f38301b
+       PMOVZXBW X2, X11                        // 66440f3830da
+       PMOVZXBW X11, X11                       // 66450f3830db
+       PMOVZXDQ (BX), X2                       // 660f383513
+       PMOVZXDQ (R11), X2                      // 66410f383513
+       PMOVZXDQ X2, X2                         // 660f3835d2
+       PMOVZXDQ X11, X2                        // 66410f3835d3
+       PMOVZXDQ (BX), X11                      // 66440f38351b
+       PMOVZXDQ (R11), X11                     // 66450f38351b
+       PMOVZXDQ X2, X11                        // 66440f3835da
+       PMOVZXDQ X11, X11                       // 66450f3835db
+       PMOVZXWD (BX), X2                       // 660f383313
+       PMOVZXWD (R11), X2                      // 66410f383313
+       PMOVZXWD X2, X2                         // 660f3833d2
+       PMOVZXWD X11, X2                        // 66410f3833d3
+       PMOVZXWD (BX), X11                      // 66440f38331b
+       PMOVZXWD (R11), X11                     // 66450f38331b
+       PMOVZXWD X2, X11                        // 66440f3833da
+       PMOVZXWD X11, X11                       // 66450f3833db
+       PMOVZXWQ (BX), X2                       // 660f383413
+       PMOVZXWQ (R11), X2                      // 66410f383413
+       PMOVZXWQ X2, X2                         // 660f3834d2
+       PMOVZXWQ X11, X2                        // 66410f3834d3
+       PMOVZXWQ (BX), X11                      // 66440f38341b
+       PMOVZXWQ (R11), X11                     // 66450f38341b
+       PMOVZXWQ X2, X11                        // 66440f3834da
+       PMOVZXWQ X11, X11                       // 66450f3834db
+       PMULDQ (BX), X2                         // 660f382813
+       PMULDQ (R11), X2                        // 66410f382813
+       PMULDQ X2, X2                           // 660f3828d2
+       PMULDQ X11, X2                          // 66410f3828d3
+       PMULDQ (BX), X11                        // 66440f38281b
+       PMULDQ (R11), X11                       // 66450f38281b
+       PMULDQ X2, X11                          // 66440f3828da
+       PMULDQ X11, X11                         // 66450f3828db
+       //TODO: PMULHRSW (BX), M2               // 0f380b13
+       //TODO: PMULHRSW (R11), M2              // 410f380b13
+       //TODO: PMULHRSW M2, M2                 // 0f380bd2
+       //TODO: PMULHRSW M3, M2                 // 0f380bd3
+       //TODO: PMULHRSW (BX), M3               // 0f380b1b
+       //TODO: PMULHRSW (R11), M3              // 410f380b1b
+       //TODO: PMULHRSW M2, M3                 // 0f380bda
+       //TODO: PMULHRSW M3, M3                 // 0f380bdb
+       //TODO: PMULHRSW (BX), X2               // 660f380b13
+       //TODO: PMULHRSW (R11), X2              // 66410f380b13
+       //TODO: PMULHRSW X2, X2                 // 660f380bd2
+       //TODO: PMULHRSW X11, X2                // 66410f380bd3
+       //TODO: PMULHRSW (BX), X11              // 66440f380b1b
+       //TODO: PMULHRSW (R11), X11             // 66450f380b1b
+       //TODO: PMULHRSW X2, X11                // 66440f380bda
+       //TODO: PMULHRSW X11, X11               // 66450f380bdb
+       PMULHUW (BX), M2                        // 0fe413
+       PMULHUW (R11), M2                       // 410fe413
+       PMULHUW M2, M2                          // 0fe4d2
+       PMULHUW M3, M2                          // 0fe4d3
+       PMULHUW (BX), M3                        // 0fe41b
+       PMULHUW (R11), M3                       // 410fe41b
+       PMULHUW M2, M3                          // 0fe4da
+       PMULHUW M3, M3                          // 0fe4db
+       PMULHUW (BX), X2                        // 660fe413
+       PMULHUW (R11), X2                       // 66410fe413
+       PMULHUW X2, X2                          // 660fe4d2
+       PMULHUW X11, X2                         // 66410fe4d3
+       PMULHUW (BX), X11                       // 66440fe41b
+       PMULHUW (R11), X11                      // 66450fe41b
+       PMULHUW X2, X11                         // 66440fe4da
+       PMULHUW X11, X11                        // 66450fe4db
+       PMULHW (BX), M2                         // 0fe513
+       PMULHW (R11), M2                        // 410fe513
+       PMULHW M2, M2                           // 0fe5d2
+       PMULHW M3, M2                           // 0fe5d3
+       PMULHW (BX), M3                         // 0fe51b
+       PMULHW (R11), M3                        // 410fe51b
+       PMULHW M2, M3                           // 0fe5da
+       PMULHW M3, M3                           // 0fe5db
+       PMULHW (BX), X2                         // 660fe513
+       PMULHW (R11), X2                        // 66410fe513
+       PMULHW X2, X2                           // 660fe5d2
+       PMULHW X11, X2                          // 66410fe5d3
+       PMULHW (BX), X11                        // 66440fe51b
+       PMULHW (R11), X11                       // 66450fe51b
+       PMULHW X2, X11                          // 66440fe5da
+       PMULHW X11, X11                         // 66450fe5db
+       PMULLD (BX), X2                         // 660f384013
+       PMULLD (R11), X2                        // 66410f384013
+       PMULLD X2, X2                           // 660f3840d2
+       PMULLD X11, X2                          // 66410f3840d3
+       PMULLD (BX), X11                        // 66440f38401b
+       PMULLD (R11), X11                       // 66450f38401b
+       PMULLD X2, X11                          // 66440f3840da
+       PMULLD X11, X11                         // 66450f3840db
+       PMULLW (BX), M2                         // 0fd513
+       PMULLW (R11), M2                        // 410fd513
+       PMULLW M2, M2                           // 0fd5d2
+       PMULLW M3, M2                           // 0fd5d3
+       PMULLW (BX), M3                         // 0fd51b
+       PMULLW (R11), M3                        // 410fd51b
+       PMULLW M2, M3                           // 0fd5da
+       PMULLW M3, M3                           // 0fd5db
+       PMULLW (BX), X2                         // 660fd513
+       PMULLW (R11), X2                        // 66410fd513
+       PMULLW X2, X2                           // 660fd5d2
+       PMULLW X11, X2                          // 66410fd5d3
+       PMULLW (BX), X11                        // 66440fd51b
+       PMULLW (R11), X11                       // 66450fd51b
+       PMULLW X2, X11                          // 66440fd5da
+       PMULLW X11, X11                         // 66450fd5db
+       PMULULQ (BX), M2                        // 0ff413
+       PMULULQ (R11), M2                       // 410ff413
+       PMULULQ M2, M2                          // 0ff4d2
+       PMULULQ M3, M2                          // 0ff4d3
+       PMULULQ (BX), M3                        // 0ff41b
+       PMULULQ (R11), M3                       // 410ff41b
+       PMULULQ M2, M3                          // 0ff4da
+       PMULULQ M3, M3                          // 0ff4db
+       PMULULQ (BX), X2                        // 660ff413
+       PMULULQ (R11), X2                       // 66410ff413
+       PMULULQ X2, X2                          // 660ff4d2
+       PMULULQ X11, X2                         // 66410ff4d3
+       PMULULQ (BX), X11                       // 66440ff41b
+       PMULULQ (R11), X11                      // 66450ff41b
+       PMULULQ X2, X11                         // 66440ff4da
+       PMULULQ X11, X11                        // 66450ff4db
+       PUSHQ AX
+       POPQ FS                                 // 660fa1 or 0fa1
+       PUSHQ AX
+       POPQ GS                                 // 660fa9 or 0fa9
+       PUSHW AX
+       POPW (BX)                               // 668f03
+       PUSHW AX
+       POPW (R11)                              // 66418f03
+       PUSHW AX
+       POPW DX                                 // 668fc2 or 665a
+       PUSHW AX
+       POPW R11                                // 66418fc3 or 66415b
+       PUSHQ AX
+       POPQ (BX)                               // 8f03
+       PUSHQ AX
+       POPQ (R11)                              // 418f03
+       PUSHQ AX
+       POPQ DX                                 // 8fc2 or 5a
+       PUSHQ AX
+       POPQ R11                                // 418fc3 or 415b
+       POPCNTW (BX), DX                        // 66f30fb813
+       POPCNTW (R11), DX                       // 66f3410fb813
+       POPCNTW DX, DX                          // 66f30fb8d2
+       POPCNTW R11, DX                         // 66f3410fb8d3
+       POPCNTW (BX), R11                       // 66f3440fb81b
+       POPCNTW (R11), R11                      // 66f3450fb81b
+       POPCNTW DX, R11                         // 66f3440fb8da
+       POPCNTW R11, R11                        // 66f3450fb8db
+       POPCNTL (BX), DX                        // f30fb813
+       POPCNTL (R11), DX                       // f3410fb813
+       POPCNTL DX, DX                          // f30fb8d2
+       POPCNTL R11, DX                         // f3410fb8d3
+       POPCNTL (BX), R11                       // f3440fb81b
+       POPCNTL (R11), R11                      // f3450fb81b
+       POPCNTL DX, R11                         // f3440fb8da
+       POPCNTL R11, R11                        // f3450fb8db
+       POPCNTQ (BX), DX                        // f3480fb813
+       POPCNTQ (R11), DX                       // f3490fb813
+       POPCNTQ DX, DX                          // f3480fb8d2
+       POPCNTQ R11, DX                         // f3490fb8d3
+       POPCNTQ (BX), R11                       // f34c0fb81b
+       POPCNTQ (R11), R11                      // f34d0fb81b
+       POPCNTQ DX, R11                         // f34c0fb8da
+       POPCNTQ R11, R11                        // f34d0fb8db
+       PUSHFW
+       POPFW                                   // 669d
+       PUSHFQ
+       POPFQ                                   // 9d
+       POR (BX), M2                            // 0feb13
+       POR (R11), M2                           // 410feb13
+       POR M2, M2                              // 0febd2
+       POR M3, M2                              // 0febd3
+       POR (BX), M3                            // 0feb1b
+       POR (R11), M3                           // 410feb1b
+       POR M2, M3                              // 0febda
+       POR M3, M3                              // 0febdb
+       POR (BX), X2                            // 660feb13
+       POR (R11), X2                           // 66410feb13
+       POR X2, X2                              // 660febd2
+       POR X11, X2                             // 66410febd3
+       POR (BX), X11                           // 66440feb1b
+       POR (R11), X11                          // 66450feb1b
+       POR X2, X11                             // 66440febda
+       POR X11, X11                            // 66450febdb
+       PREFETCHNTA (BX)                        // 0f1803
+       PREFETCHNTA (R11)                       // 410f1803
+       PREFETCHT0 (BX)                         // 0f180b
+       PREFETCHT0 (R11)                        // 410f180b
+       PREFETCHT1 (BX)                         // 0f1813
+       PREFETCHT1 (R11)                        // 410f1813
+       PREFETCHT2 (BX)                         // 0f181b
+       PREFETCHT2 (R11)                        // 410f181b
+       //TODO: PREFETCHW (BX)                  // 0f0d0b
+       //TODO: PREFETCHW (R11)                 // 410f0d0b
+       //TODO: PREFETCHWT1 (BX)                // 0f0d13
+       //TODO: PREFETCHWT1 (R11)               // 410f0d13
+       //TODO: PSADBW (BX), M2                 // 0ff613
+       //TODO: PSADBW (R11), M2                // 410ff613
+       //TODO: PSADBW M2, M2                   // 0ff6d2
+       //TODO: PSADBW M3, M2                   // 0ff6d3
+       //TODO: PSADBW (BX), M3                 // 0ff61b
+       //TODO: PSADBW (R11), M3                // 410ff61b
+       //TODO: PSADBW M2, M3                   // 0ff6da
+       //TODO: PSADBW M3, M3                   // 0ff6db
+       PSADBW (BX), X2                         // 660ff613
+       PSADBW (R11), X2                        // 66410ff613
+       PSADBW X2, X2                           // 660ff6d2
+       PSADBW X11, X2                          // 66410ff6d3
+       PSADBW (BX), X11                        // 66440ff61b
+       PSADBW (R11), X11                       // 66450ff61b
+       PSADBW X2, X11                          // 66440ff6da
+       PSADBW X11, X11                         // 66450ff6db
+       //TODO: PSHUFB (BX), M2                 // 0f380013
+       //TODO: PSHUFB (R11), M2                // 410f380013
+       //TODO: PSHUFB M2, M2                   // 0f3800d2
+       //TODO: PSHUFB M3, M2                   // 0f3800d3
+       //TODO: PSHUFB (BX), M3                 // 0f38001b
+       //TODO: PSHUFB (R11), M3                // 410f38001b
+       //TODO: PSHUFB M2, M3                   // 0f3800da
+       //TODO: PSHUFB M3, M3                   // 0f3800db
+       PSHUFB (BX), X2                         // 660f380013
+       PSHUFB (R11), X2                        // 66410f380013
+       PSHUFB X2, X2                           // 660f3800d2
+       PSHUFB X11, X2                          // 66410f3800d3
+       PSHUFB (BX), X11                        // 66440f38001b
+       PSHUFB (R11), X11                       // 66450f38001b
+       PSHUFB X2, X11                          // 66440f3800da
+       PSHUFB X11, X11                         // 66450f3800db
+       PSHUFD $7, (BX), X2                     // 660f701307
+       PSHUFL $7, (BX), X2                     // 660f701307
+       PSHUFD $7, (R11), X2                    // 66410f701307
+       PSHUFL $7, (R11), X2                    // 66410f701307
+       PSHUFD $7, X2, X2                       // 660f70d207
+       PSHUFL $7, X2, X2                       // 660f70d207
+       PSHUFD $7, X11, X2                      // 66410f70d307
+       PSHUFL $7, X11, X2                      // 66410f70d307
+       PSHUFD $7, (BX), X11                    // 66440f701b07
+       PSHUFL $7, (BX), X11                    // 66440f701b07
+       PSHUFD $7, (R11), X11                   // 66450f701b07
+       PSHUFL $7, (R11), X11                   // 66450f701b07
+       PSHUFD $7, X2, X11                      // 66440f70da07
+       PSHUFL $7, X2, X11                      // 66440f70da07
+       PSHUFD $7, X11, X11                     // 66450f70db07
+       PSHUFL $7, X11, X11                     // 66450f70db07
+       PSHUFHW $7, (BX), X2                    // f30f701307
+       PSHUFHW $7, (R11), X2                   // f3410f701307
+       PSHUFHW $7, X2, X2                      // f30f70d207
+       PSHUFHW $7, X11, X2                     // f3410f70d307
+       PSHUFHW $7, (BX), X11                   // f3440f701b07
+       PSHUFHW $7, (R11), X11                  // f3450f701b07
+       PSHUFHW $7, X2, X11                     // f3440f70da07
+       PSHUFHW $7, X11, X11                    // f3450f70db07
+       PSHUFLW $7, (BX), X2                    // f20f701307
+       PSHUFLW $7, (R11), X2                   // f2410f701307
+       PSHUFLW $7, X2, X2                      // f20f70d207
+       PSHUFLW $7, X11, X2                     // f2410f70d307
+       PSHUFLW $7, (BX), X11                   // f2440f701b07
+       PSHUFLW $7, (R11), X11                  // f2450f701b07
+       PSHUFLW $7, X2, X11                     // f2440f70da07
+       PSHUFLW $7, X11, X11                    // f2450f70db07
+       PSHUFW $7, (BX), M2                     // 0f701307
+       PSHUFW $7, (R11), M2                    // 410f701307
+       PSHUFW $7, M2, M2                       // 0f70d207
+       PSHUFW $7, M3, M2                       // 0f70d307
+       PSHUFW $7, (BX), M3                     // 0f701b07
+       PSHUFW $7, (R11), M3                    // 410f701b07
+       PSHUFW $7, M2, M3                       // 0f70da07
+       PSHUFW $7, M3, M3                       // 0f70db07
+       //TODO: PSIGNB (BX), M2                 // 0f380813
+       //TODO: PSIGNB (R11), M2                // 410f380813
+       //TODO: PSIGNB M2, M2                   // 0f3808d2
+       //TODO: PSIGNB M3, M2                   // 0f3808d3
+       //TODO: PSIGNB (BX), M3                 // 0f38081b
+       //TODO: PSIGNB (R11), M3                // 410f38081b
+       //TODO: PSIGNB M2, M3                   // 0f3808da
+       //TODO: PSIGNB M3, M3                   // 0f3808db
+       //TODO: PSIGNB (BX), X2                 // 660f380813
+       //TODO: PSIGNB (R11), X2                // 66410f380813
+       //TODO: PSIGNB X2, X2                   // 660f3808d2
+       //TODO: PSIGNB X11, X2                  // 66410f3808d3
+       //TODO: PSIGNB (BX), X11                // 66440f38081b
+       //TODO: PSIGNB (R11), X11               // 66450f38081b
+       //TODO: PSIGNB X2, X11                  // 66440f3808da
+       //TODO: PSIGNB X11, X11                 // 66450f3808db
+       //TODO: PSIGND (BX), M2                 // 0f380a13
+       //TODO: PSIGND (R11), M2                // 410f380a13
+       //TODO: PSIGND M2, M2                   // 0f380ad2
+       //TODO: PSIGND M3, M2                   // 0f380ad3
+       //TODO: PSIGND (BX), M3                 // 0f380a1b
+       //TODO: PSIGND (R11), M3                // 410f380a1b
+       //TODO: PSIGND M2, M3                   // 0f380ada
+       //TODO: PSIGND M3, M3                   // 0f380adb
+       //TODO: PSIGND (BX), X2                 // 660f380a13
+       //TODO: PSIGND (R11), X2                // 66410f380a13
+       //TODO: PSIGND X2, X2                   // 660f380ad2
+       //TODO: PSIGND X11, X2                  // 66410f380ad3
+       //TODO: PSIGND (BX), X11                // 66440f380a1b
+       //TODO: PSIGND (R11), X11               // 66450f380a1b
+       //TODO: PSIGND X2, X11                  // 66440f380ada
+       //TODO: PSIGND X11, X11                 // 66450f380adb
+       //TODO: PSIGNW (BX), M2                 // 0f380913
+       //TODO: PSIGNW (R11), M2                // 410f380913
+       //TODO: PSIGNW M2, M2                   // 0f3809d2
+       //TODO: PSIGNW M3, M2                   // 0f3809d3
+       //TODO: PSIGNW (BX), M3                 // 0f38091b
+       //TODO: PSIGNW (R11), M3                // 410f38091b
+       //TODO: PSIGNW M2, M3                   // 0f3809da
+       //TODO: PSIGNW M3, M3                   // 0f3809db
+       //TODO: PSIGNW (BX), X2                 // 660f380913
+       //TODO: PSIGNW (R11), X2                // 66410f380913
+       //TODO: PSIGNW X2, X2                   // 660f3809d2
+       //TODO: PSIGNW X11, X2                  // 66410f3809d3
+       //TODO: PSIGNW (BX), X11                // 66440f38091b
+       //TODO: PSIGNW (R11), X11               // 66450f38091b
+       //TODO: PSIGNW X2, X11                  // 66440f3809da
+       //TODO: PSIGNW X11, X11                 // 66450f3809db
+       PSLLL (BX), M2                          // 0ff213
+       PSLLL (R11), M2                         // 410ff213
+       PSLLL M2, M2                            // 0ff2d2
+       PSLLL M3, M2                            // 0ff2d3
+       PSLLL (BX), M3                          // 0ff21b
+       PSLLL (R11), M3                         // 410ff21b
+       PSLLL M2, M3                            // 0ff2da
+       PSLLL M3, M3                            // 0ff2db
+       PSLLL $7, M2                            // 0f72f207
+       PSLLL $7, M3                            // 0f72f307
+       PSLLL (BX), X2                          // 660ff213
+       PSLLL (R11), X2                         // 66410ff213
+       PSLLL X2, X2                            // 660ff2d2
+       PSLLL X11, X2                           // 66410ff2d3
+       PSLLL (BX), X11                         // 66440ff21b
+       PSLLL (R11), X11                        // 66450ff21b
+       PSLLL X2, X11                           // 66440ff2da
+       PSLLL X11, X11                          // 66450ff2db
+       PSLLL $7, X2                            // 660f72f207
+       PSLLL $7, X11                           // 66410f72f307
+       PSLLO $7, X2                            // 660f73fa07
+       PSLLO $7, X11                           // 66410f73fb07
+       PSLLQ (BX), M2                          // 0ff313
+       PSLLQ (R11), M2                         // 410ff313
+       PSLLQ M2, M2                            // 0ff3d2
+       PSLLQ M3, M2                            // 0ff3d3
+       PSLLQ (BX), M3                          // 0ff31b
+       PSLLQ (R11), M3                         // 410ff31b
+       PSLLQ M2, M3                            // 0ff3da
+       PSLLQ M3, M3                            // 0ff3db
+       PSLLQ $7, M2                            // 0f73f207
+       PSLLQ $7, M3                            // 0f73f307
+       PSLLQ (BX), X2                          // 660ff313
+       PSLLQ (R11), X2                         // 66410ff313
+       PSLLQ X2, X2                            // 660ff3d2
+       PSLLQ X11, X2                           // 66410ff3d3
+       PSLLQ (BX), X11                         // 66440ff31b
+       PSLLQ (R11), X11                        // 66450ff31b
+       PSLLQ X2, X11                           // 66440ff3da
+       PSLLQ X11, X11                          // 66450ff3db
+       PSLLQ $7, X2                            // 660f73f207
+       PSLLQ $7, X11                           // 66410f73f307
+       PSLLW (BX), M2                          // 0ff113
+       PSLLW (R11), M2                         // 410ff113
+       PSLLW M2, M2                            // 0ff1d2
+       PSLLW M3, M2                            // 0ff1d3
+       PSLLW (BX), M3                          // 0ff11b
+       PSLLW (R11), M3                         // 410ff11b
+       PSLLW M2, M3                            // 0ff1da
+       PSLLW M3, M3                            // 0ff1db
+       PSLLW $7, M2                            // 0f71f207
+       PSLLW $7, M3                            // 0f71f307
+       PSLLW (BX), X2                          // 660ff113
+       PSLLW (R11), X2                         // 66410ff113
+       PSLLW X2, X2                            // 660ff1d2
+       PSLLW X11, X2                           // 66410ff1d3
+       PSLLW (BX), X11                         // 66440ff11b
+       PSLLW (R11), X11                        // 66450ff11b
+       PSLLW X2, X11                           // 66440ff1da
+       PSLLW X11, X11                          // 66450ff1db
+       PSLLW $7, X2                            // 660f71f207
+       PSLLW $7, X11                           // 66410f71f307
+       PSRAL (BX), M2                          // 0fe213
+       PSRAL (R11), M2                         // 410fe213
+       PSRAL M2, M2                            // 0fe2d2
+       PSRAL M3, M2                            // 0fe2d3
+       PSRAL (BX), M3                          // 0fe21b
+       PSRAL (R11), M3                         // 410fe21b
+       PSRAL M2, M3                            // 0fe2da
+       PSRAL M3, M3                            // 0fe2db
+       PSRAL $7, M2                            // 0f72e207
+       PSRAL $7, M3                            // 0f72e307
+       PSRAL (BX), X2                          // 660fe213
+       PSRAL (R11), X2                         // 66410fe213
+       PSRAL X2, X2                            // 660fe2d2
+       PSRAL X11, X2                           // 66410fe2d3
+       PSRAL (BX), X11                         // 66440fe21b
+       PSRAL (R11), X11                        // 66450fe21b
+       PSRAL X2, X11                           // 66440fe2da
+       PSRAL X11, X11                          // 66450fe2db
+       PSRAL $7, X2                            // 660f72e207
+       PSRAL $7, X11                           // 66410f72e307
+       PSRAW (BX), M2                          // 0fe113
+       PSRAW (R11), M2                         // 410fe113
+       PSRAW M2, M2                            // 0fe1d2
+       PSRAW M3, M2                            // 0fe1d3
+       PSRAW (BX), M3                          // 0fe11b
+       PSRAW (R11), M3                         // 410fe11b
+       PSRAW M2, M3                            // 0fe1da
+       PSRAW M3, M3                            // 0fe1db
+       PSRAW $7, M2                            // 0f71e207
+       PSRAW $7, M3                            // 0f71e307
+       PSRAW (BX), X2                          // 660fe113
+       PSRAW (R11), X2                         // 66410fe113
+       PSRAW X2, X2                            // 660fe1d2
+       PSRAW X11, X2                           // 66410fe1d3
+       PSRAW (BX), X11                         // 66440fe11b
+       PSRAW (R11), X11                        // 66450fe11b
+       PSRAW X2, X11                           // 66440fe1da
+       PSRAW X11, X11                          // 66450fe1db
+       PSRAW $7, X2                            // 660f71e207
+       PSRAW $7, X11                           // 66410f71e307
+       PSRLL (BX), M2                          // 0fd213
+       PSRLL (R11), M2                         // 410fd213
+       PSRLL M2, M2                            // 0fd2d2
+       PSRLL M3, M2                            // 0fd2d3
+       PSRLL (BX), M3                          // 0fd21b
+       PSRLL (R11), M3                         // 410fd21b
+       PSRLL M2, M3                            // 0fd2da
+       PSRLL M3, M3                            // 0fd2db
+       PSRLL $7, M2                            // 0f72d207
+       PSRLL $7, M3                            // 0f72d307
+       PSRLL (BX), X2                          // 660fd213
+       PSRLL (R11), X2                         // 66410fd213
+       PSRLL X2, X2                            // 660fd2d2
+       PSRLL X11, X2                           // 66410fd2d3
+       PSRLL (BX), X11                         // 66440fd21b
+       PSRLL (R11), X11                        // 66450fd21b
+       PSRLL X2, X11                           // 66440fd2da
+       PSRLL X11, X11                          // 66450fd2db
+       PSRLL $7, X2                            // 660f72d207
+       PSRLL $7, X11                           // 66410f72d307
+       PSRLO $7, X2                            // 660f73da07
+       PSRLO $7, X11                           // 66410f73db07
+       PSRLQ (BX), M2                          // 0fd313
+       PSRLQ (R11), M2                         // 410fd313
+       PSRLQ M2, M2                            // 0fd3d2
+       PSRLQ M3, M2                            // 0fd3d3
+       PSRLQ (BX), M3                          // 0fd31b
+       PSRLQ (R11), M3                         // 410fd31b
+       PSRLQ M2, M3                            // 0fd3da
+       PSRLQ M3, M3                            // 0fd3db
+       PSRLQ $7, M2                            // 0f73d207
+       PSRLQ $7, M3                            // 0f73d307
+       PSRLQ (BX), X2                          // 660fd313
+       PSRLQ (R11), X2                         // 66410fd313
+       PSRLQ X2, X2                            // 660fd3d2
+       PSRLQ X11, X2                           // 66410fd3d3
+       PSRLQ (BX), X11                         // 66440fd31b
+       PSRLQ (R11), X11                        // 66450fd31b
+       PSRLQ X2, X11                           // 66440fd3da
+       PSRLQ X11, X11                          // 66450fd3db
+       PSRLQ $7, X2                            // 660f73d207
+       PSRLQ $7, X11                           // 66410f73d307
+       PSRLW (BX), M2                          // 0fd113
+       PSRLW (R11), M2                         // 410fd113
+       PSRLW M2, M2                            // 0fd1d2
+       PSRLW M3, M2                            // 0fd1d3
+       PSRLW (BX), M3                          // 0fd11b
+       PSRLW (R11), M3                         // 410fd11b
+       PSRLW M2, M3                            // 0fd1da
+       PSRLW M3, M3                            // 0fd1db
+       PSRLW $7, M2                            // 0f71d207
+       PSRLW $7, M3                            // 0f71d307
+       PSRLW (BX), X2                          // 660fd113
+       PSRLW (R11), X2                         // 66410fd113
+       PSRLW X2, X2                            // 660fd1d2
+       PSRLW X11, X2                           // 66410fd1d3
+       PSRLW (BX), X11                         // 66440fd11b
+       PSRLW (R11), X11                        // 66450fd11b
+       PSRLW X2, X11                           // 66440fd1da
+       PSRLW X11, X11                          // 66450fd1db
+       PSRLW $7, X2                            // 660f71d207
+       PSRLW $7, X11                           // 66410f71d307
+       //TODO: PSUBB (BX), M2                  // 0ff813
+       //TODO: PSUBB (R11), M2                 // 410ff813
+       //TODO: PSUBB M2, M2                    // 0ff8d2
+       //TODO: PSUBB M3, M2                    // 0ff8d3
+       //TODO: PSUBB (BX), M3                  // 0ff81b
+       //TODO: PSUBB (R11), M3                 // 410ff81b
+       //TODO: PSUBB M2, M3                    // 0ff8da
+       //TODO: PSUBB M3, M3                    // 0ff8db
+       PSUBB (BX), X2                          // 660ff813
+       PSUBB (R11), X2                         // 66410ff813
+       PSUBB X2, X2                            // 660ff8d2
+       PSUBB X11, X2                           // 66410ff8d3
+       PSUBB (BX), X11                         // 66440ff81b
+       PSUBB (R11), X11                        // 66450ff81b
+       PSUBB X2, X11                           // 66440ff8da
+       PSUBB X11, X11                          // 66450ff8db
+       //TODO: PSUBL (BX), M2                  // 0ffa13
+       //TODO: PSUBL (R11), M2                 // 410ffa13
+       //TODO: PSUBL M2, M2                    // 0ffad2
+       //TODO: PSUBL M3, M2                    // 0ffad3
+       //TODO: PSUBL (BX), M3                  // 0ffa1b
+       //TODO: PSUBL (R11), M3                 // 410ffa1b
+       //TODO: PSUBL M2, M3                    // 0ffada
+       //TODO: PSUBL M3, M3                    // 0ffadb
+       PSUBL (BX), X2                          // 660ffa13
+       PSUBL (R11), X2                         // 66410ffa13
+       PSUBL X2, X2                            // 660ffad2
+       PSUBL X11, X2                           // 66410ffad3
+       PSUBL (BX), X11                         // 66440ffa1b
+       PSUBL (R11), X11                        // 66450ffa1b
+       PSUBL X2, X11                           // 66440ffada
+       PSUBL X11, X11                          // 66450ffadb
+       //TODO: PSUBQ (BX), M2                  // 0ffb13
+       //TODO: PSUBQ (R11), M2                 // 410ffb13
+       //TODO: PSUBQ M2, M2                    // 0ffbd2
+       //TODO: PSUBQ M3, M2                    // 0ffbd3
+       //TODO: PSUBQ (BX), M3                  // 0ffb1b
+       //TODO: PSUBQ (R11), M3                 // 410ffb1b
+       //TODO: PSUBQ M2, M3                    // 0ffbda
+       //TODO: PSUBQ M3, M3                    // 0ffbdb
+       PSUBQ (BX), X2                          // 660ffb13
+       PSUBQ (R11), X2                         // 66410ffb13
+       PSUBQ X2, X2                            // 660ffbd2
+       PSUBQ X11, X2                           // 66410ffbd3
+       PSUBQ (BX), X11                         // 66440ffb1b
+       PSUBQ (R11), X11                        // 66450ffb1b
+       PSUBQ X2, X11                           // 66440ffbda
+       PSUBQ X11, X11                          // 66450ffbdb
+       //TODO: PSUBSB (BX), M2                 // 0fe813
+       //TODO: PSUBSB (R11), M2                // 410fe813
+       //TODO: PSUBSB M2, M2                   // 0fe8d2
+       //TODO: PSUBSB M3, M2                   // 0fe8d3
+       //TODO: PSUBSB (BX), M3                 // 0fe81b
+       //TODO: PSUBSB (R11), M3                // 410fe81b
+       //TODO: PSUBSB M2, M3                   // 0fe8da
+       //TODO: PSUBSB M3, M3                   // 0fe8db
+       PSUBSB (BX), X2                         // 660fe813
+       PSUBSB (R11), X2                        // 66410fe813
+       PSUBSB X2, X2                           // 660fe8d2
+       PSUBSB X11, X2                          // 66410fe8d3
+       PSUBSB (BX), X11                        // 66440fe81b
+       PSUBSB (R11), X11                       // 66450fe81b
+       PSUBSB X2, X11                          // 66440fe8da
+       PSUBSB X11, X11                         // 66450fe8db
+       //TODO: PSUBSW (BX), M2                 // 0fe913
+       //TODO: PSUBSW (R11), M2                // 410fe913
+       //TODO: PSUBSW M2, M2                   // 0fe9d2
+       //TODO: PSUBSW M3, M2                   // 0fe9d3
+       //TODO: PSUBSW (BX), M3                 // 0fe91b
+       //TODO: PSUBSW (R11), M3                // 410fe91b
+       //TODO: PSUBSW M2, M3                   // 0fe9da
+       //TODO: PSUBSW M3, M3                   // 0fe9db
+       PSUBSW (BX), X2                         // 660fe913
+       PSUBSW (R11), X2                        // 66410fe913
+       PSUBSW X2, X2                           // 660fe9d2
+       PSUBSW X11, X2                          // 66410fe9d3
+       PSUBSW (BX), X11                        // 66440fe91b
+       PSUBSW (R11), X11                       // 66450fe91b
+       PSUBSW X2, X11                          // 66440fe9da
+       PSUBSW X11, X11                         // 66450fe9db
+       //TODO: PSUBUSB (BX), M2                // 0fd813
+       //TODO: PSUBUSB (R11), M2               // 410fd813
+       //TODO: PSUBUSB M2, M2                  // 0fd8d2
+       //TODO: PSUBUSB M3, M2                  // 0fd8d3
+       //TODO: PSUBUSB (BX), M3                // 0fd81b
+       //TODO: PSUBUSB (R11), M3               // 410fd81b
+       //TODO: PSUBUSB M2, M3                  // 0fd8da
+       //TODO: PSUBUSB M3, M3                  // 0fd8db
+       PSUBUSB (BX), X2                        // 660fd813
+       PSUBUSB (R11), X2                       // 66410fd813
+       PSUBUSB X2, X2                          // 660fd8d2
+       PSUBUSB X11, X2                         // 66410fd8d3
+       PSUBUSB (BX), X11                       // 66440fd81b
+       PSUBUSB (R11), X11                      // 66450fd81b
+       PSUBUSB X2, X11                         // 66440fd8da
+       PSUBUSB X11, X11                        // 66450fd8db
+       //TODO: PSUBUSW (BX), M2                // 0fd913
+       //TODO: PSUBUSW (R11), M2               // 410fd913
+       //TODO: PSUBUSW M2, M2                  // 0fd9d2
+       //TODO: PSUBUSW M3, M2                  // 0fd9d3
+       //TODO: PSUBUSW (BX), M3                // 0fd91b
+       //TODO: PSUBUSW (R11), M3               // 410fd91b
+       //TODO: PSUBUSW M2, M3                  // 0fd9da
+       //TODO: PSUBUSW M3, M3                  // 0fd9db
+       PSUBUSW (BX), X2                        // 660fd913
+       PSUBUSW (R11), X2                       // 66410fd913
+       PSUBUSW X2, X2                          // 660fd9d2
+       PSUBUSW X11, X2                         // 66410fd9d3
+       PSUBUSW (BX), X11                       // 66440fd91b
+       PSUBUSW (R11), X11                      // 66450fd91b
+       PSUBUSW X2, X11                         // 66440fd9da
+       PSUBUSW X11, X11                        // 66450fd9db
+       //TODO: PSUBW (BX), M2                  // 0ff913
+       //TODO: PSUBW (R11), M2                 // 410ff913
+       //TODO: PSUBW M2, M2                    // 0ff9d2
+       //TODO: PSUBW M3, M2                    // 0ff9d3
+       //TODO: PSUBW (BX), M3                  // 0ff91b
+       //TODO: PSUBW (R11), M3                 // 410ff91b
+       //TODO: PSUBW M2, M3                    // 0ff9da
+       //TODO: PSUBW M3, M3                    // 0ff9db
+       PSUBW (BX), X2                          // 660ff913
+       PSUBW (R11), X2                         // 66410ff913
+       PSUBW X2, X2                            // 660ff9d2
+       PSUBW X11, X2                           // 66410ff9d3
+       PSUBW (BX), X11                         // 66440ff91b
+       PSUBW (R11), X11                        // 66450ff91b
+       PSUBW X2, X11                           // 66440ff9da
+       PSUBW X11, X11                          // 66450ff9db
+       //TODO: PTEST (BX), X2                  // 660f381713
+       //TODO: PTEST (R11), X2                 // 66410f381713
+       //TODO: PTEST X2, X2                    // 660f3817d2
+       //TODO: PTEST X11, X2                   // 66410f3817d3
+       //TODO: PTEST (BX), X11                 // 66440f38171b
+       //TODO: PTEST (R11), X11                // 66450f38171b
+       //TODO: PTEST X2, X11                   // 66440f3817da
+       //TODO: PTEST X11, X11                  // 66450f3817db
+       PUNPCKHBW (BX), M2                      // 0f6813
+       PUNPCKHBW (R11), M2                     // 410f6813
+       PUNPCKHBW M2, M2                        // 0f68d2
+       PUNPCKHBW M3, M2                        // 0f68d3
+       PUNPCKHBW (BX), M3                      // 0f681b
+       PUNPCKHBW (R11), M3                     // 410f681b
+       PUNPCKHBW M2, M3                        // 0f68da
+       PUNPCKHBW M3, M3                        // 0f68db
+       PUNPCKHBW (BX), X2                      // 660f6813
+       PUNPCKHBW (R11), X2                     // 66410f6813
+       PUNPCKHBW X2, X2                        // 660f68d2
+       PUNPCKHBW X11, X2                       // 66410f68d3
+       PUNPCKHBW (BX), X11                     // 66440f681b
+       PUNPCKHBW (R11), X11                    // 66450f681b
+       PUNPCKHBW X2, X11                       // 66440f68da
+       PUNPCKHBW X11, X11                      // 66450f68db
+       PUNPCKHLQ (BX), M2                      // 0f6a13
+       PUNPCKHLQ (R11), M2                     // 410f6a13
+       PUNPCKHLQ M2, M2                        // 0f6ad2
+       PUNPCKHLQ M3, M2                        // 0f6ad3
+       PUNPCKHLQ (BX), M3                      // 0f6a1b
+       PUNPCKHLQ (R11), M3                     // 410f6a1b
+       PUNPCKHLQ M2, M3                        // 0f6ada
+       PUNPCKHLQ M3, M3                        // 0f6adb
+       PUNPCKHLQ (BX), X2                      // 660f6a13
+       PUNPCKHLQ (R11), X2                     // 66410f6a13
+       PUNPCKHLQ X2, X2                        // 660f6ad2
+       PUNPCKHLQ X11, X2                       // 66410f6ad3
+       PUNPCKHLQ (BX), X11                     // 66440f6a1b
+       PUNPCKHLQ (R11), X11                    // 66450f6a1b
+       PUNPCKHLQ X2, X11                       // 66440f6ada
+       PUNPCKHLQ X11, X11                      // 66450f6adb
+       PUNPCKHQDQ (BX), X2                     // 660f6d13
+       PUNPCKHQDQ (R11), X2                    // 66410f6d13
+       PUNPCKHQDQ X2, X2                       // 660f6dd2
+       PUNPCKHQDQ X11, X2                      // 66410f6dd3
+       PUNPCKHQDQ (BX), X11                    // 66440f6d1b
+       PUNPCKHQDQ (R11), X11                   // 66450f6d1b
+       PUNPCKHQDQ X2, X11                      // 66440f6dda
+       PUNPCKHQDQ X11, X11                     // 66450f6ddb
+       PUNPCKHWL (BX), M2                      // 0f6913
+       PUNPCKHWL (R11), M2                     // 410f6913
+       PUNPCKHWL M2, M2                        // 0f69d2
+       PUNPCKHWL M3, M2                        // 0f69d3
+       PUNPCKHWL (BX), M3                      // 0f691b
+       PUNPCKHWL (R11), M3                     // 410f691b
+       PUNPCKHWL M2, M3                        // 0f69da
+       PUNPCKHWL M3, M3                        // 0f69db
+       PUNPCKHWL (BX), X2                      // 660f6913
+       PUNPCKHWL (R11), X2                     // 66410f6913
+       PUNPCKHWL X2, X2                        // 660f69d2
+       PUNPCKHWL X11, X2                       // 66410f69d3
+       PUNPCKHWL (BX), X11                     // 66440f691b
+       PUNPCKHWL (R11), X11                    // 66450f691b
+       PUNPCKHWL X2, X11                       // 66440f69da
+       PUNPCKHWL X11, X11                      // 66450f69db
+       PUNPCKLBW (BX), M2                      // 0f6013
+       PUNPCKLBW (R11), M2                     // 410f6013
+       PUNPCKLBW M2, M2                        // 0f60d2
+       PUNPCKLBW M3, M2                        // 0f60d3
+       PUNPCKLBW (BX), M3                      // 0f601b
+       PUNPCKLBW (R11), M3                     // 410f601b
+       PUNPCKLBW M2, M3                        // 0f60da
+       PUNPCKLBW M3, M3                        // 0f60db
+       PUNPCKLBW (BX), X2                      // 660f6013
+       PUNPCKLBW (R11), X2                     // 66410f6013
+       PUNPCKLBW X2, X2                        // 660f60d2
+       PUNPCKLBW X11, X2                       // 66410f60d3
+       PUNPCKLBW (BX), X11                     // 66440f601b
+       PUNPCKLBW (R11), X11                    // 66450f601b
+       PUNPCKLBW X2, X11                       // 66440f60da
+       PUNPCKLBW X11, X11                      // 66450f60db
+       PUNPCKLLQ (BX), M2                      // 0f6213
+       PUNPCKLLQ (R11), M2                     // 410f6213
+       PUNPCKLLQ M2, M2                        // 0f62d2
+       PUNPCKLLQ M3, M2                        // 0f62d3
+       PUNPCKLLQ (BX), M3                      // 0f621b
+       PUNPCKLLQ (R11), M3                     // 410f621b
+       PUNPCKLLQ M2, M3                        // 0f62da
+       PUNPCKLLQ M3, M3                        // 0f62db
+       PUNPCKLLQ (BX), X2                      // 660f6213
+       PUNPCKLLQ (R11), X2                     // 66410f6213
+       PUNPCKLLQ X2, X2                        // 660f62d2
+       PUNPCKLLQ X11, X2                       // 66410f62d3
+       PUNPCKLLQ (BX), X11                     // 66440f621b
+       PUNPCKLLQ (R11), X11                    // 66450f621b
+       PUNPCKLLQ X2, X11                       // 66440f62da
+       PUNPCKLLQ X11, X11                      // 66450f62db
+       PUNPCKLQDQ (BX), X2                     // 660f6c13
+       PUNPCKLQDQ (R11), X2                    // 66410f6c13
+       PUNPCKLQDQ X2, X2                       // 660f6cd2
+       PUNPCKLQDQ X11, X2                      // 66410f6cd3
+       PUNPCKLQDQ (BX), X11                    // 66440f6c1b
+       PUNPCKLQDQ (R11), X11                   // 66450f6c1b
+       PUNPCKLQDQ X2, X11                      // 66440f6cda
+       PUNPCKLQDQ X11, X11                     // 66450f6cdb
+       PUNPCKLWL (BX), M2                      // 0f6113
+       PUNPCKLWL (R11), M2                     // 410f6113
+       PUNPCKLWL M2, M2                        // 0f61d2
+       PUNPCKLWL M3, M2                        // 0f61d3
+       PUNPCKLWL (BX), M3                      // 0f611b
+       PUNPCKLWL (R11), M3                     // 410f611b
+       PUNPCKLWL M2, M3                        // 0f61da
+       PUNPCKLWL M3, M3                        // 0f61db
+       PUNPCKLWL (BX), X2                      // 660f6113
+       PUNPCKLWL (R11), X2                     // 66410f6113
+       PUNPCKLWL X2, X2                        // 660f61d2
+       PUNPCKLWL X11, X2                       // 66410f61d3
+       PUNPCKLWL (BX), X11                     // 66440f611b
+       PUNPCKLWL (R11), X11                    // 66450f611b
+       PUNPCKLWL X2, X11                       // 66440f61da
+       PUNPCKLWL X11, X11                      // 66450f61db
+       PUSHQ FS                                // 0fa0
+       POPQ AX
+       PUSHQ GS                                // 0fa8
+       POPQ AX
+       PUSHW $61731                            // 666823f1
+       POPW AX
+       PUSHQ $4045620583                       // 68674523f1
+       POPQ AX
+       PUSHQ $7                                // 6a07
+       POPQ AX
+       PUSHW (BX)                              // 66ff33
+       POPW AX
+       PUSHW (R11)                             // 6641ff33
+       POPW AX
+       PUSHW DX                                // 66fff2 or 6652
+       POPW AX
+       PUSHW R11                               // 6641fff3 or 664153
+       POPW AX
+       PUSHQ (BX)                              // ff33
+       POPQ AX
+       PUSHQ (R11)                             // 41ff33
+       POPQ AX
+       PUSHQ DX                                // fff2 or 52
+       POPQ AX
+       PUSHQ R11                               // 41fff3 or 4153
+       POPQ AX
+       PUSHFW                                  // 669c
+       POPFW
+       PUSHFQ                                  // 9c
+       POPFQ
+       PXOR (BX), M2                           // 0fef13
+       PXOR (R11), M2                          // 410fef13
+       PXOR M2, M2                             // 0fefd2
+       PXOR M3, M2                             // 0fefd3
+       PXOR (BX), M3                           // 0fef1b
+       PXOR (R11), M3                          // 410fef1b
+       PXOR M2, M3                             // 0fefda
+       PXOR M3, M3                             // 0fefdb
+       PXOR (BX), X2                           // 660fef13
+       PXOR (R11), X2                          // 66410fef13
+       PXOR X2, X2                             // 660fefd2
+       PXOR X11, X2                            // 66410fefd3
+       PXOR (BX), X11                          // 66440fef1b
+       PXOR (R11), X11                         // 66450fef1b
+       PXOR X2, X11                            // 66440fefda
+       PXOR X11, X11                           // 66450fefdb
+       RCLW $1, (BX)                           // 66d113
+       RCLW $1, (R11)                          // 6641d113
+       RCLW $1, DX                             // 66d1d2
+       RCLW $1, R11                            // 6641d1d3
+       RCLW CL, (BX)                           // 66d313
+       RCLW CL, (R11)                          // 6641d313
+       RCLW CL, DX                             // 66d3d2
+       RCLW CL, R11                            // 6641d3d3
+       RCLW $7, (BX)                           // 66c11307
+       RCLW $7, (R11)                          // 6641c11307
+       RCLW $7, DX                             // 66c1d207
+       RCLW $7, R11                            // 6641c1d307
+       RCLL $1, (BX)                           // d113
+       RCLL $1, (R11)                          // 41d113
+       RCLL $1, DX                             // d1d2
+       RCLL $1, R11                            // 41d1d3
+       RCLL CL, (BX)                           // d313
+       RCLL CL, (R11)                          // 41d313
+       RCLL CL, DX                             // d3d2
+       RCLL CL, R11                            // 41d3d3
+       RCLL $7, (BX)                           // c11307
+       RCLL $7, (R11)                          // 41c11307
+       RCLL $7, DX                             // c1d207
+       RCLL $7, R11                            // 41c1d307
+       RCLQ $1, (BX)                           // 48d113
+       RCLQ $1, (R11)                          // 49d113
+       RCLQ $1, DX                             // 48d1d2
+       RCLQ $1, R11                            // 49d1d3
+       RCLQ CL, (BX)                           // 48d313
+       RCLQ CL, (R11)                          // 49d313
+       RCLQ CL, DX                             // 48d3d2
+       RCLQ CL, R11                            // 49d3d3
+       RCLQ $7, (BX)                           // 48c11307
+       RCLQ $7, (R11)                          // 49c11307
+       RCLQ $7, DX                             // 48c1d207
+       RCLQ $7, R11                            // 49c1d307
+       RCLB $1, (BX)                           // d013
+       RCLB $1, (R11)                          // 41d013
+       RCLB $1, DL                             // d0d2
+       RCLB $1, R11                            // 41d0d3
+       RCLB CL, (BX)                           // d213
+       RCLB CL, (R11)                          // 41d213
+       RCLB CL, DL                             // d2d2
+       RCLB CL, R11                            // 41d2d3
+       RCLB $7, (BX)                           // c01307
+       RCLB $7, (R11)                          // 41c01307
+       RCLB $7, DL                             // c0d207
+       RCLB $7, R11                            // 41c0d307
+       RCPPS (BX), X2                          // 0f5313
+       RCPPS (R11), X2                         // 410f5313
+       RCPPS X2, X2                            // 0f53d2
+       RCPPS X11, X2                           // 410f53d3
+       RCPPS (BX), X11                         // 440f531b
+       RCPPS (R11), X11                        // 450f531b
+       RCPPS X2, X11                           // 440f53da
+       RCPPS X11, X11                          // 450f53db
+       RCPSS (BX), X2                          // f30f5313
+       RCPSS (R11), X2                         // f3410f5313
+       RCPSS X2, X2                            // f30f53d2
+       RCPSS X11, X2                           // f3410f53d3
+       RCPSS (BX), X11                         // f3440f531b
+       RCPSS (R11), X11                        // f3450f531b
+       RCPSS X2, X11                           // f3440f53da
+       RCPSS X11, X11                          // f3450f53db
+       RCRW $1, (BX)                           // 66d11b
+       RCRW $1, (R11)                          // 6641d11b
+       RCRW $1, DX                             // 66d1da
+       RCRW $1, R11                            // 6641d1db
+       RCRW CL, (BX)                           // 66d31b
+       RCRW CL, (R11)                          // 6641d31b
+       RCRW CL, DX                             // 66d3da
+       RCRW CL, R11                            // 6641d3db
+       RCRW $7, (BX)                           // 66c11b07
+       RCRW $7, (R11)                          // 6641c11b07
+       RCRW $7, DX                             // 66c1da07
+       RCRW $7, R11                            // 6641c1db07
+       RCRL $1, (BX)                           // d11b
+       RCRL $1, (R11)                          // 41d11b
+       RCRL $1, DX                             // d1da
+       RCRL $1, R11                            // 41d1db
+       RCRL CL, (BX)                           // d31b
+       RCRL CL, (R11)                          // 41d31b
+       RCRL CL, DX                             // d3da
+       RCRL CL, R11                            // 41d3db
+       RCRL $7, (BX)                           // c11b07
+       RCRL $7, (R11)                          // 41c11b07
+       RCRL $7, DX                             // c1da07
+       RCRL $7, R11                            // 41c1db07
+       RCRQ $1, (BX)                           // 48d11b
+       RCRQ $1, (R11)                          // 49d11b
+       RCRQ $1, DX                             // 48d1da
+       RCRQ $1, R11                            // 49d1db
+       RCRQ CL, (BX)                           // 48d31b
+       RCRQ CL, (R11)                          // 49d31b
+       RCRQ CL, DX                             // 48d3da
+       RCRQ CL, R11                            // 49d3db
+       RCRQ $7, (BX)                           // 48c11b07
+       RCRQ $7, (R11)                          // 49c11b07
+       RCRQ $7, DX                             // 48c1da07
+       RCRQ $7, R11                            // 49c1db07
+       RCRB $1, (BX)                           // d01b
+       RCRB $1, (R11)                          // 41d01b
+       RCRB $1, DL                             // d0da
+       RCRB $1, R11                            // 41d0db
+       RCRB CL, (BX)                           // d21b
+       RCRB CL, (R11)                          // 41d21b
+       RCRB CL, DL                             // d2da
+       RCRB CL, R11                            // 41d2db
+       RCRB $7, (BX)                           // c01b07
+       RCRB $7, (R11)                          // 41c01b07
+       RCRB $7, DL                             // c0da07
+       RCRB $7, R11                            // 41c0db07
+       //TODO: RDFSBASE DX                     // f30faec2 or f3480faec2
+       //TODO: RDFSBASE R11                    // f3410faec3 or f3490faec3
+       //TODO: RDGSBASE DX                     // f30faeca or f3480faeca
+       //TODO: RDGSBASE R11                    // f3410faecb or f3490faecb
+       RDMSR                                   // 0f32
+       //TODO: RDPKRU                          // 0f01ee
+       RDPMC                                   // 0f33
+       //TODO: RDRAND DX                       // 660fc7f2 or 0fc7f2 or 480fc7f2
+       //TODO: RDRAND R11                      // 66410fc7f3 or 410fc7f3 or 490fc7f3
+       //TODO: RDSEED DX                       // 660fc7fa or 0fc7fa or 480fc7fa
+       //TODO: RDSEED R11                      // 66410fc7fb or 410fc7fb or 490fc7fb
+       RDTSC                                   // 0f31
+       //TODO: RDTSCP                          // 0f01f9
+       JCS 2(PC)
+       //TODO: RETQ                            // c3
+       JCS 2(PC)
+       //TODO: RETQ $0xf123                    // c223f1
+       JCS 2(PC)
+       //TODO: RETFQ                           // cb
+       JCS 2(PC)
+       //TODO: RETFQ $0xf123                   // ca23f1
+       ROLW $1, (BX)                           // 66d103
+       ROLW $1, (R11)                          // 6641d103
+       ROLW $1, DX                             // 66d1c2
+       ROLW $1, R11                            // 6641d1c3
+       ROLW CL, (BX)                           // 66d303
+       ROLW CL, (R11)                          // 6641d303
+       ROLW CL, DX                             // 66d3c2
+       ROLW CL, R11                            // 6641d3c3
+       ROLW $7, (BX)                           // 66c10307
+       ROLW $7, (R11)                          // 6641c10307
+       ROLW $7, DX                             // 66c1c207
+       ROLW $7, R11                            // 6641c1c307
+       ROLL $1, (BX)                           // d103
+       ROLL $1, (R11)                          // 41d103
+       ROLL $1, DX                             // d1c2
+       ROLL $1, R11                            // 41d1c3
+       ROLL CL, (BX)                           // d303
+       ROLL CL, (R11)                          // 41d303
+       ROLL CL, DX                             // d3c2
+       ROLL CL, R11                            // 41d3c3
+       ROLL $7, (BX)                           // c10307
+       ROLL $7, (R11)                          // 41c10307
+       ROLL $7, DX                             // c1c207
+       ROLL $7, R11                            // 41c1c307
+       ROLQ $1, (BX)                           // 48d103
+       ROLQ $1, (R11)                          // 49d103
+       ROLQ $1, DX                             // 48d1c2
+       ROLQ $1, R11                            // 49d1c3
+       ROLQ CL, (BX)                           // 48d303
+       ROLQ CL, (R11)                          // 49d303
+       ROLQ CL, DX                             // 48d3c2
+       ROLQ CL, R11                            // 49d3c3
+       ROLQ $7, (BX)                           // 48c10307
+       ROLQ $7, (R11)                          // 49c10307
+       ROLQ $7, DX                             // 48c1c207
+       ROLQ $7, R11                            // 49c1c307
+       ROLB $1, (BX)                           // d003
+       ROLB $1, (R11)                          // 41d003
+       ROLB $1, DL                             // d0c2
+       ROLB $1, R11                            // 41d0c3
+       ROLB CL, (BX)                           // d203
+       ROLB CL, (R11)                          // 41d203
+       ROLB CL, DL                             // d2c2
+       ROLB CL, R11                            // 41d2c3
+       ROLB $7, (BX)                           // c00307
+       ROLB $7, (R11)                          // 41c00307
+       ROLB $7, DL                             // c0c207
+       ROLB $7, R11                            // 41c0c307
+       RORW $1, (BX)                           // 66d10b
+       RORW $1, (R11)                          // 6641d10b
+       RORW $1, DX                             // 66d1ca
+       RORW $1, R11                            // 6641d1cb
+       RORW CL, (BX)                           // 66d30b
+       RORW CL, (R11)                          // 6641d30b
+       RORW CL, DX                             // 66d3ca
+       RORW CL, R11                            // 6641d3cb
+       RORW $7, (BX)                           // 66c10b07
+       RORW $7, (R11)                          // 6641c10b07
+       RORW $7, DX                             // 66c1ca07
+       RORW $7, R11                            // 6641c1cb07
+       RORL $1, (BX)                           // d10b
+       RORL $1, (R11)                          // 41d10b
+       RORL $1, DX                             // d1ca
+       RORL $1, R11                            // 41d1cb
+       RORL CL, (BX)                           // d30b
+       RORL CL, (R11)                          // 41d30b
+       RORL CL, DX                             // d3ca
+       RORL CL, R11                            // 41d3cb
+       RORL $7, (BX)                           // c10b07
+       RORL $7, (R11)                          // 41c10b07
+       RORL $7, DX                             // c1ca07
+       RORL $7, R11                            // 41c1cb07
+       RORQ $1, (BX)                           // 48d10b
+       RORQ $1, (R11)                          // 49d10b
+       RORQ $1, DX                             // 48d1ca
+       RORQ $1, R11                            // 49d1cb
+       RORQ CL, (BX)                           // 48d30b
+       RORQ CL, (R11)                          // 49d30b
+       RORQ CL, DX                             // 48d3ca
+       RORQ CL, R11                            // 49d3cb
+       RORQ $7, (BX)                           // 48c10b07
+       RORQ $7, (R11)                          // 49c10b07
+       RORQ $7, DX                             // 48c1ca07
+       RORQ $7, R11                            // 49c1cb07
+       RORB $1, (BX)                           // d00b
+       RORB $1, (R11)                          // 41d00b
+       RORB $1, DL                             // d0ca
+       RORB $1, R11                            // 41d0cb
+       RORB CL, (BX)                           // d20b
+       RORB CL, (R11)                          // 41d20b
+       RORB CL, DL                             // d2ca
+       RORB CL, R11                            // 41d2cb
+       RORB $7, (BX)                           // c00b07
+       RORB $7, (R11)                          // 41c00b07
+       RORB $7, DL                             // c0ca07
+       RORB $7, R11                            // 41c0cb07
+       //TODO: RORXL $7, (BX), DX              // c4e37bf01307
+       //TODO: RORXL $7, (R11), DX             // c4c37bf01307
+       //TODO: RORXL $7, DX, DX                // c4e37bf0d207
+       //TODO: RORXL $7, R11, DX               // c4c37bf0d307
+       //TODO: RORXL $7, (BX), R11             // c4637bf01b07
+       //TODO: RORXL $7, (R11), R11            // c4437bf01b07
+       //TODO: RORXL $7, DX, R11               // c4637bf0da07
+       //TODO: RORXL $7, R11, R11              // c4437bf0db07
+       //TODO: RORXQ $7, (BX), DX              // c4e3fbf01307
+       //TODO: RORXQ $7, (R11), DX             // c4c3fbf01307
+       //TODO: RORXQ $7, DX, DX                // c4e3fbf0d207
+       //TODO: RORXQ $7, R11, DX               // c4c3fbf0d307
+       //TODO: RORXQ $7, (BX), R11             // c463fbf01b07
+       //TODO: RORXQ $7, (R11), R11            // c443fbf01b07
+       //TODO: RORXQ $7, DX, R11               // c463fbf0da07
+       //TODO: RORXQ $7, R11, R11              // c443fbf0db07
+       ROUNDPD $7, (BX), X2                    // 660f3a091307
+       ROUNDPD $7, (R11), X2                   // 66410f3a091307
+       ROUNDPD $7, X2, X2                      // 660f3a09d207
+       ROUNDPD $7, X11, X2                     // 66410f3a09d307
+       ROUNDPD $7, (BX), X11                   // 66440f3a091b07
+       ROUNDPD $7, (R11), X11                  // 66450f3a091b07
+       ROUNDPD $7, X2, X11                     // 66440f3a09da07
+       ROUNDPD $7, X11, X11                    // 66450f3a09db07
+       ROUNDPS $7, (BX), X2                    // 660f3a081307
+       ROUNDPS $7, (R11), X2                   // 66410f3a081307
+       ROUNDPS $7, X2, X2                      // 660f3a08d207
+       ROUNDPS $7, X11, X2                     // 66410f3a08d307
+       ROUNDPS $7, (BX), X11                   // 66440f3a081b07
+       ROUNDPS $7, (R11), X11                  // 66450f3a081b07
+       ROUNDPS $7, X2, X11                     // 66440f3a08da07
+       ROUNDPS $7, X11, X11                    // 66450f3a08db07
+       ROUNDSD $7, (BX), X2                    // 660f3a0b1307
+       ROUNDSD $7, (R11), X2                   // 66410f3a0b1307
+       ROUNDSD $7, X2, X2                      // 660f3a0bd207
+       ROUNDSD $7, X11, X2                     // 66410f3a0bd307
+       ROUNDSD $7, (BX), X11                   // 66440f3a0b1b07
+       ROUNDSD $7, (R11), X11                  // 66450f3a0b1b07
+       ROUNDSD $7, X2, X11                     // 66440f3a0bda07
+       ROUNDSD $7, X11, X11                    // 66450f3a0bdb07
+       ROUNDSS $7, (BX), X2                    // 660f3a0a1307
+       ROUNDSS $7, (R11), X2                   // 66410f3a0a1307
+       ROUNDSS $7, X2, X2                      // 660f3a0ad207
+       ROUNDSS $7, X11, X2                     // 66410f3a0ad307
+       ROUNDSS $7, (BX), X11                   // 66440f3a0a1b07
+       ROUNDSS $7, (R11), X11                  // 66450f3a0a1b07
+       ROUNDSS $7, X2, X11                     // 66440f3a0ada07
+       ROUNDSS $7, X11, X11                    // 66450f3a0adb07
+       RSM                                     // 0faa
+       RSQRTPS (BX), X2                        // 0f5213
+       RSQRTPS (R11), X2                       // 410f5213
+       RSQRTPS X2, X2                          // 0f52d2
+       RSQRTPS X11, X2                         // 410f52d3
+       RSQRTPS (BX), X11                       // 440f521b
+       RSQRTPS (R11), X11                      // 450f521b
+       RSQRTPS X2, X11                         // 440f52da
+       RSQRTPS X11, X11                        // 450f52db
+       RSQRTSS (BX), X2                        // f30f5213
+       RSQRTSS (R11), X2                       // f3410f5213
+       RSQRTSS X2, X2                          // f30f52d2
+       RSQRTSS X11, X2                         // f3410f52d3
+       RSQRTSS (BX), X11                       // f3440f521b
+       RSQRTSS (R11), X11                      // f3450f521b
+       RSQRTSS X2, X11                         // f3440f52da
+       RSQRTSS X11, X11                        // f3450f52db
+       //TODO: SAHF                            // 9e
+       SARW $1, (BX)                           // 66d13b
+       SARW $1, (R11)                          // 6641d13b
+       SARW $1, DX                             // 66d1fa
+       SARW $1, R11                            // 6641d1fb
+       SARW CL, (BX)                           // 66d33b
+       SARW CL, (R11)                          // 6641d33b
+       SARW CL, DX                             // 66d3fa
+       SARW CL, R11                            // 6641d3fb
+       SARW $7, (BX)                           // 66c13b07
+       SARW $7, (R11)                          // 6641c13b07
+       SARW $7, DX                             // 66c1fa07
+       SARW $7, R11                            // 6641c1fb07
+       SARL $1, (BX)                           // d13b
+       SARL $1, (R11)                          // 41d13b
+       SARL $1, DX                             // d1fa
+       SARL $1, R11                            // 41d1fb
+       SARL CL, (BX)                           // d33b
+       SARL CL, (R11)                          // 41d33b
+       SARL CL, DX                             // d3fa
+       SARL CL, R11                            // 41d3fb
+       SARL $7, (BX)                           // c13b07
+       SARL $7, (R11)                          // 41c13b07
+       SARL $7, DX                             // c1fa07
+       SARL $7, R11                            // 41c1fb07
+       SARQ $1, (BX)                           // 48d13b
+       SARQ $1, (R11)                          // 49d13b
+       SARQ $1, DX                             // 48d1fa
+       SARQ $1, R11                            // 49d1fb
+       SARQ CL, (BX)                           // 48d33b
+       SARQ CL, (R11)                          // 49d33b
+       SARQ CL, DX                             // 48d3fa
+       SARQ CL, R11                            // 49d3fb
+       SARQ $7, (BX)                           // 48c13b07
+       SARQ $7, (R11)                          // 49c13b07
+       SARQ $7, DX                             // 48c1fa07
+       SARQ $7, R11                            // 49c1fb07
+       SARB $1, (BX)                           // d03b
+       SARB $1, (R11)                          // 41d03b
+       SARB $1, DL                             // d0fa
+       SARB $1, R11                            // 41d0fb
+       SARB CL, (BX)                           // d23b
+       SARB CL, (R11)                          // 41d23b
+       SARB CL, DL                             // d2fa
+       SARB CL, R11                            // 41d2fb
+       SARB $7, (BX)                           // c03b07
+       SARB $7, (R11)                          // 41c03b07
+       SARB $7, DL                             // c0fa07
+       SARB $7, R11                            // 41c0fb07
+       SARXL R9, (BX), DX                      // c4e232f713
+       SARXL R9, (R11), DX                     // c4c232f713
+       SARXL R9, DX, DX                        // c4e232f7d2
+       SARXL R9, R11, DX                       // c4c232f7d3
+       SARXL R9, (BX), R11                     // c46232f71b
+       SARXL R9, (R11), R11                    // c44232f71b
+       SARXL R9, DX, R11                       // c46232f7da
+       SARXL R9, R11, R11                      // c44232f7db
+       SARXQ R14, (BX), DX                     // c4e28af713
+       SARXQ R14, (R11), DX                    // c4c28af713
+       SARXQ R14, DX, DX                       // c4e28af7d2
+       SARXQ R14, R11, DX                      // c4c28af7d3
+       SARXQ R14, (BX), R11                    // c4628af71b
+       SARXQ R14, (R11), R11                   // c4428af71b
+       SARXQ R14, DX, R11                      // c4628af7da
+       SARXQ R14, R11, R11                     // c4428af7db
+       SBBB $7, AL                             // 1c07
+       SBBW $61731, AX                         // 661d23f1
+       SBBL $4045620583, AX                    // 1d674523f1
+       SBBQ $-249346713, AX                    // 481d674523f1
+       SBBW $61731, (BX)                       // 66811b23f1
+       SBBW $61731, (R11)                      // 6641811b23f1
+       SBBW $61731, DX                         // 6681da23f1
+       SBBW $61731, R11                        // 664181db23f1
+       SBBW $7, (BX)                           // 66831b07
+       SBBW $7, (R11)                          // 6641831b07
+       SBBW $7, DX                             // 6683da07
+       SBBW $7, R11                            // 664183db07
+       SBBW DX, (BX)                           // 661913
+       SBBW R11, (BX)                          // 6644191b
+       SBBW DX, (R11)                          // 66411913
+       SBBW R11, (R11)                         // 6645191b
+       SBBW DX, DX                             // 6619d2 or 661bd2
+       SBBW R11, DX                            // 664419da or 66411bd3
+       SBBW DX, R11                            // 664119d3 or 66441bda
+       SBBW R11, R11                           // 664519db or 66451bdb
+       SBBL $4045620583, (BX)                  // 811b674523f1
+       SBBL $4045620583, (R11)                 // 41811b674523f1
+       SBBL $4045620583, DX                    // 81da674523f1
+       SBBL $4045620583, R11                   // 4181db674523f1
+       SBBL $7, (BX)                           // 831b07
+       SBBL $7, (R11)                          // 41831b07
+       SBBL $7, DX                             // 83da07
+       SBBL $7, R11                            // 4183db07
+       SBBL DX, (BX)                           // 1913
+       SBBL R11, (BX)                          // 44191b
+       SBBL DX, (R11)                          // 411913
+       SBBL R11, (R11)                         // 45191b
+       SBBL DX, DX                             // 19d2 or 1bd2
+       SBBL R11, DX                            // 4419da or 411bd3
+       SBBL DX, R11                            // 4119d3 or 441bda
+       SBBL R11, R11                           // 4519db or 451bdb
+       SBBQ $-249346713, (BX)                  // 48811b674523f1
+       SBBQ $-249346713, (R11)                 // 49811b674523f1
+       SBBQ $-249346713, DX                    // 4881da674523f1
+       SBBQ $-249346713, R11                   // 4981db674523f1
+       SBBQ $7, (BX)                           // 48831b07
+       SBBQ $7, (R11)                          // 49831b07
+       SBBQ $7, DX                             // 4883da07
+       SBBQ $7, R11                            // 4983db07
+       SBBQ DX, (BX)                           // 481913
+       SBBQ R11, (BX)                          // 4c191b
+       SBBQ DX, (R11)                          // 491913
+       SBBQ R11, (R11)                         // 4d191b
+       SBBQ DX, DX                             // 4819d2 or 481bd2
+       SBBQ R11, DX                            // 4c19da or 491bd3
+       SBBQ DX, R11                            // 4919d3 or 4c1bda
+       SBBQ R11, R11                           // 4d19db or 4d1bdb
+       SBBB $7, (BX)                           // 801b07
+       SBBB $7, (R11)                          // 41801b07
+       SBBB $7, DL                             // 80da07
+       SBBB $7, R11                            // 4180db07
+       SBBB DL, (BX)                           // 1813
+       SBBB R11, (BX)                          // 44181b
+       SBBB DL, (R11)                          // 411813
+       SBBB R11, (R11)                         // 45181b
+       SBBB DL, DL                             // 18d2 or 1ad2
+       SBBB R11, DL                            // 4418da or 411ad3
+       SBBB DL, R11                            // 4118d3 or 441ada
+       SBBB R11, R11                           // 4518db or 451adb
+       SBBW (BX), DX                           // 661b13
+       SBBW (R11), DX                          // 66411b13
+       SBBW (BX), R11                          // 66441b1b
+       SBBW (R11), R11                         // 66451b1b
+       SBBL (BX), DX                           // 1b13
+       SBBL (R11), DX                          // 411b13
+       SBBL (BX), R11                          // 441b1b
+       SBBL (R11), R11                         // 451b1b
+       SBBQ (BX), DX                           // 481b13
+       SBBQ (R11), DX                          // 491b13
+       SBBQ (BX), R11                          // 4c1b1b
+       SBBQ (R11), R11                         // 4d1b1b
+       SBBB (BX), DL                           // 1a13
+       SBBB (R11), DL                          // 411a13
+       SBBB (BX), R11                          // 441a1b
+       SBBB (R11), R11                         // 451a1b
+       SCASB                                   // ae
+       SCASL                                   // af
+       SCASQ                                   // 48af
+       SCASW                                   // 66af
+       SETHI (BX)                              // 0f9703
+       SETHI (R11)                             // 410f9703
+       SETHI DL                                // 0f97c2
+       SETHI R11                               // 410f97c3
+       SETCC (BX)                              // 0f9303
+       SETCC (R11)                             // 410f9303
+       SETCC DL                                // 0f93c2
+       SETCC R11                               // 410f93c3
+       SETCS (BX)                              // 0f9203
+       SETCS (R11)                             // 410f9203
+       SETCS DL                                // 0f92c2
+       SETCS R11                               // 410f92c3
+       SETLS (BX)                              // 0f9603
+       SETLS (R11)                             // 410f9603
+       SETLS DL                                // 0f96c2
+       SETLS R11                               // 410f96c3
+       SETEQ (BX)                              // 0f9403
+       SETEQ (R11)                             // 410f9403
+       SETEQ DL                                // 0f94c2
+       SETEQ R11                               // 410f94c3
+       SETGT (BX)                              // 0f9f03
+       SETGT (R11)                             // 410f9f03
+       SETGT DL                                // 0f9fc2
+       SETGT R11                               // 410f9fc3
+       SETGE (BX)                              // 0f9d03
+       SETGE (R11)                             // 410f9d03
+       SETGE DL                                // 0f9dc2
+       SETGE R11                               // 410f9dc3
+       SETLT (BX)                              // 0f9c03
+       SETLT (R11)                             // 410f9c03
+       SETLT DL                                // 0f9cc2
+       SETLT R11                               // 410f9cc3
+       SETLE (BX)                              // 0f9e03
+       SETLE (R11)                             // 410f9e03
+       SETLE DL                                // 0f9ec2
+       SETLE R11                               // 410f9ec3
+       SETNE (BX)                              // 0f9503
+       SETNE (R11)                             // 410f9503
+       SETNE DL                                // 0f95c2
+       SETNE R11                               // 410f95c3
+       SETOC (BX)                              // 0f9103
+       SETOC (R11)                             // 410f9103
+       SETOC DL                                // 0f91c2
+       SETOC R11                               // 410f91c3
+       SETPC (BX)                              // 0f9b03
+       SETPC (R11)                             // 410f9b03
+       SETPC DL                                // 0f9bc2
+       SETPC R11                               // 410f9bc3
+       SETPL (BX)                              // 0f9903
+       SETPL (R11)                             // 410f9903
+       SETPL DL                                // 0f99c2
+       SETPL R11                               // 410f99c3
+       SETOS (BX)                              // 0f9003
+       SETOS (R11)                             // 410f9003
+       SETOS DL                                // 0f90c2
+       SETOS R11                               // 410f90c3
+       SETPS (BX)                              // 0f9a03
+       SETPS (R11)                             // 410f9a03
+       SETPS DL                                // 0f9ac2
+       SETPS R11                               // 410f9ac3
+       SETMI (BX)                              // 0f9803
+       SETMI (R11)                             // 410f9803
+       SETMI DL                                // 0f98c2
+       SETMI R11                               // 410f98c3
+       SFENCE                                  // 0faef8
+       //TODO: SGDT (BX)                       // 0f0103
+       //TODO: SGDT (R11)                      // 410f0103
+       SHLW $1, (BX)                           // 66d123
+       SHLW $1, (R11)                          // 6641d123
+       SHLW $1, DX                             // 66d1e2
+       SHLW $1, R11                            // 6641d1e3
+       SHLW CL, (BX)                           // 66d323
+       SHLW CL, (R11)                          // 6641d323
+       SHLW CL, DX                             // 66d3e2
+       SHLW CL, R11                            // 6641d3e3
+       SHLW $7, (BX)                           // 66c12307
+       SHLW $7, (R11)                          // 6641c12307
+       SHLW $7, DX                             // 66c1e207
+       SHLW $7, R11                            // 6641c1e307
+       SHLL $1, (BX)                           // d123
+       SHLL $1, (R11)                          // 41d123
+       SHLL $1, DX                             // d1e2
+       SHLL $1, R11                            // 41d1e3
+       SHLL CL, (BX)                           // d323
+       SHLL CL, (R11)                          // 41d323
+       SHLL CL, DX                             // d3e2
+       SHLL CL, R11                            // 41d3e3
+       SHLL $7, (BX)                           // c12307
+       SHLL $7, (R11)                          // 41c12307
+       SHLL $7, DX                             // c1e207
+       SHLL $7, R11                            // 41c1e307
+       SHLQ $1, (BX)                           // 48d123
+       SHLQ $1, (R11)                          // 49d123
+       SHLQ $1, DX                             // 48d1e2
+       SHLQ $1, R11                            // 49d1e3
+       SHLQ CL, (BX)                           // 48d323
+       SHLQ CL, (R11)                          // 49d323
+       SHLQ CL, DX                             // 48d3e2
+       SHLQ CL, R11                            // 49d3e3
+       SHLQ $7, (BX)                           // 48c12307
+       SHLQ $7, (R11)                          // 49c12307
+       SHLQ $7, DX                             // 48c1e207
+       SHLQ $7, R11                            // 49c1e307
+       SHLB $1, (BX)                           // d023
+       SHLB $1, (R11)                          // 41d023
+       SHLB $1, DL                             // d0e2
+       SHLB $1, R11                            // 41d0e3
+       SHLB CL, (BX)                           // d223
+       SHLB CL, (R11)                          // 41d223
+       SHLB CL, DL                             // d2e2
+       SHLB CL, R11                            // 41d2e3
+       SHLB $7, (BX)                           // c02307
+       SHLB $7, (R11)                          // 41c02307
+       SHLB $7, DL                             // c0e207
+       SHLB $7, R11                            // 41c0e307
+       SHLW CL, DX, (BX)                       // 660fa513
+       SHLW CL, R11, (BX)                      // 66440fa51b
+       SHLW CL, DX, (R11)                      // 66410fa513
+       SHLW CL, R11, (R11)                     // 66450fa51b
+       SHLW CL, DX, DX                         // 660fa5d2
+       SHLW CL, R11, DX                        // 66440fa5da
+       SHLW CL, DX, R11                        // 66410fa5d3
+       SHLW CL, R11, R11                       // 66450fa5db
+       SHLW $7, DX, (BX)                       // 660fa41307
+       SHLW $7, R11, (BX)                      // 66440fa41b07
+       SHLW $7, DX, (R11)                      // 66410fa41307
+       SHLW $7, R11, (R11)                     // 66450fa41b07
+       SHLW $7, DX, DX                         // 660fa4d207
+       SHLW $7, R11, DX                        // 66440fa4da07
+       SHLW $7, DX, R11                        // 66410fa4d307
+       SHLW $7, R11, R11                       // 66450fa4db07
+       SHLL CL, DX, (BX)                       // 0fa513
+       SHLL CL, R11, (BX)                      // 440fa51b
+       SHLL CL, DX, (R11)                      // 410fa513
+       SHLL CL, R11, (R11)                     // 450fa51b
+       SHLL CL, DX, DX                         // 0fa5d2
+       SHLL CL, R11, DX                        // 440fa5da
+       SHLL CL, DX, R11                        // 410fa5d3
+       SHLL CL, R11, R11                       // 450fa5db
+       SHLL $7, DX, (BX)                       // 0fa41307
+       SHLL $7, R11, (BX)                      // 440fa41b07
+       SHLL $7, DX, (R11)                      // 410fa41307
+       SHLL $7, R11, (R11)                     // 450fa41b07
+       SHLL $7, DX, DX                         // 0fa4d207
+       SHLL $7, R11, DX                        // 440fa4da07
+       SHLL $7, DX, R11                        // 410fa4d307
+       SHLL $7, R11, R11                       // 450fa4db07
+       SHLQ CL, DX, (BX)                       // 480fa513
+       SHLQ CL, R11, (BX)                      // 4c0fa51b
+       SHLQ CL, DX, (R11)                      // 490fa513
+       SHLQ CL, R11, (R11)                     // 4d0fa51b
+       SHLQ CL, DX, DX                         // 480fa5d2
+       SHLQ CL, R11, DX                        // 4c0fa5da
+       SHLQ CL, DX, R11                        // 490fa5d3
+       SHLQ CL, R11, R11                       // 4d0fa5db
+       SHLQ $7, DX, (BX)                       // 480fa41307
+       SHLQ $7, R11, (BX)                      // 4c0fa41b07
+       SHLQ $7, DX, (R11)                      // 490fa41307
+       SHLQ $7, R11, (R11)                     // 4d0fa41b07
+       SHLQ $7, DX, DX                         // 480fa4d207
+       SHLQ $7, R11, DX                        // 4c0fa4da07
+       SHLQ $7, DX, R11                        // 490fa4d307
+       SHLQ $7, R11, R11                       // 4d0fa4db07
+       SHLXL R9, (BX), DX                      // c4e231f713
+       SHLXL R9, (R11), DX                     // c4c231f713
+       SHLXL R9, DX, DX                        // c4e231f7d2
+       SHLXL R9, R11, DX                       // c4c231f7d3
+       SHLXL R9, (BX), R11                     // c46231f71b
+       SHLXL R9, (R11), R11                    // c44231f71b
+       SHLXL R9, DX, R11                       // c46231f7da
+       SHLXL R9, R11, R11                      // c44231f7db
+       SHLXQ R14, (BX), DX                     // c4e289f713
+       SHLXQ R14, (R11), DX                    // c4c289f713
+       SHLXQ R14, DX, DX                       // c4e289f7d2
+       SHLXQ R14, R11, DX                      // c4c289f7d3
+       SHLXQ R14, (BX), R11                    // c46289f71b
+       SHLXQ R14, (R11), R11                   // c44289f71b
+       SHLXQ R14, DX, R11                      // c46289f7da
+       SHLXQ R14, R11, R11                     // c44289f7db
+       SHRW $1, (BX)                           // 66d12b
+       SHRW $1, (R11)                          // 6641d12b
+       SHRW $1, DX                             // 66d1ea
+       SHRW $1, R11                            // 6641d1eb
+       SHRW CL, (BX)                           // 66d32b
+       SHRW CL, (R11)                          // 6641d32b
+       SHRW CL, DX                             // 66d3ea
+       SHRW CL, R11                            // 6641d3eb
+       SHRW $7, (BX)                           // 66c12b07
+       SHRW $7, (R11)                          // 6641c12b07
+       SHRW $7, DX                             // 66c1ea07
+       SHRW $7, R11                            // 6641c1eb07
+       SHRL $1, (BX)                           // d12b
+       SHRL $1, (R11)                          // 41d12b
+       SHRL $1, DX                             // d1ea
+       SHRL $1, R11                            // 41d1eb
+       SHRL CL, (BX)                           // d32b
+       SHRL CL, (R11)                          // 41d32b
+       SHRL CL, DX                             // d3ea
+       SHRL CL, R11                            // 41d3eb
+       SHRL $7, (BX)                           // c12b07
+       SHRL $7, (R11)                          // 41c12b07
+       SHRL $7, DX                             // c1ea07
+       SHRL $7, R11                            // 41c1eb07
+       SHRQ $1, (BX)                           // 48d12b
+       SHRQ $1, (R11)                          // 49d12b
+       SHRQ $1, DX                             // 48d1ea
+       SHRQ $1, R11                            // 49d1eb
+       SHRQ CL, (BX)                           // 48d32b
+       SHRQ CL, (R11)                          // 49d32b
+       SHRQ CL, DX                             // 48d3ea
+       SHRQ CL, R11                            // 49d3eb
+       SHRQ $7, (BX)                           // 48c12b07
+       SHRQ $7, (R11)                          // 49c12b07
+       SHRQ $7, DX                             // 48c1ea07
+       SHRQ $7, R11                            // 49c1eb07
+       SHRB $1, (BX)                           // d02b
+       SHRB $1, (R11)                          // 41d02b
+       SHRB $1, DL                             // d0ea
+       SHRB $1, R11                            // 41d0eb
+       SHRB CL, (BX)                           // d22b
+       SHRB CL, (R11)                          // 41d22b
+       SHRB CL, DL                             // d2ea
+       SHRB CL, R11                            // 41d2eb
+       SHRB $7, (BX)                           // c02b07
+       SHRB $7, (R11)                          // 41c02b07
+       SHRB $7, DL                             // c0ea07
+       SHRB $7, R11                            // 41c0eb07
+       SHRW CL, DX, (BX)                       // 660fad13
+       SHRW CL, R11, (BX)                      // 66440fad1b
+       SHRW CL, DX, (R11)                      // 66410fad13
+       SHRW CL, R11, (R11)                     // 66450fad1b
+       SHRW CL, DX, DX                         // 660fadd2
+       SHRW CL, R11, DX                        // 66440fadda
+       SHRW CL, DX, R11                        // 66410fadd3
+       SHRW CL, R11, R11                       // 66450faddb
+       SHRW $7, DX, (BX)                       // 660fac1307
+       SHRW $7, R11, (BX)                      // 66440fac1b07
+       SHRW $7, DX, (R11)                      // 66410fac1307
+       SHRW $7, R11, (R11)                     // 66450fac1b07
+       SHRW $7, DX, DX                         // 660facd207
+       SHRW $7, R11, DX                        // 66440facda07
+       SHRW $7, DX, R11                        // 66410facd307
+       SHRW $7, R11, R11                       // 66450facdb07
+       SHRL CL, DX, (BX)                       // 0fad13
+       SHRL CL, R11, (BX)                      // 440fad1b
+       SHRL CL, DX, (R11)                      // 410fad13
+       SHRL CL, R11, (R11)                     // 450fad1b
+       SHRL CL, DX, DX                         // 0fadd2
+       SHRL CL, R11, DX                        // 440fadda
+       SHRL CL, DX, R11                        // 410fadd3
+       SHRL CL, R11, R11                       // 450faddb
+       SHRL $7, DX, (BX)                       // 0fac1307
+       SHRL $7, R11, (BX)                      // 440fac1b07
+       SHRL $7, DX, (R11)                      // 410fac1307
+       SHRL $7, R11, (R11)                     // 450fac1b07
+       SHRL $7, DX, DX                         // 0facd207
+       SHRL $7, R11, DX                        // 440facda07
+       SHRL $7, DX, R11                        // 410facd307
+       SHRL $7, R11, R11                       // 450facdb07
+       SHRQ CL, DX, (BX)                       // 480fad13
+       SHRQ CL, R11, (BX)                      // 4c0fad1b
+       SHRQ CL, DX, (R11)                      // 490fad13
+       SHRQ CL, R11, (R11)                     // 4d0fad1b
+       SHRQ CL, DX, DX                         // 480fadd2
+       SHRQ CL, R11, DX                        // 4c0fadda
+       SHRQ CL, DX, R11                        // 490fadd3
+       SHRQ CL, R11, R11                       // 4d0faddb
+       SHRQ $7, DX, (BX)                       // 480fac1307
+       SHRQ $7, R11, (BX)                      // 4c0fac1b07
+       SHRQ $7, DX, (R11)                      // 490fac1307
+       SHRQ $7, R11, (R11)                     // 4d0fac1b07
+       SHRQ $7, DX, DX                         // 480facd207
+       SHRQ $7, R11, DX                        // 4c0facda07
+       SHRQ $7, DX, R11                        // 490facd307
+       SHRQ $7, R11, R11                       // 4d0facdb07
+       SHRXL R9, (BX), DX                      // c4e233f713
+       SHRXL R9, (R11), DX                     // c4c233f713
+       SHRXL R9, DX, DX                        // c4e233f7d2
+       SHRXL R9, R11, DX                       // c4c233f7d3
+       SHRXL R9, (BX), R11                     // c46233f71b
+       SHRXL R9, (R11), R11                    // c44233f71b
+       SHRXL R9, DX, R11                       // c46233f7da
+       SHRXL R9, R11, R11                      // c44233f7db
+       SHRXQ R14, (BX), DX                     // c4e28bf713
+       SHRXQ R14, (R11), DX                    // c4c28bf713
+       SHRXQ R14, DX, DX                       // c4e28bf7d2
+       SHRXQ R14, R11, DX                      // c4c28bf7d3
+       SHRXQ R14, (BX), R11                    // c4628bf71b
+       SHRXQ R14, (R11), R11                   // c4428bf71b
+       SHRXQ R14, DX, R11                      // c4628bf7da
+       SHRXQ R14, R11, R11                     // c4428bf7db
+       SHUFPD $7, (BX), X2                     // 660fc61307
+       SHUFPD $7, (R11), X2                    // 66410fc61307
+       SHUFPD $7, X2, X2                       // 660fc6d207
+       SHUFPD $7, X11, X2                      // 66410fc6d307
+       SHUFPD $7, (BX), X11                    // 66440fc61b07
+       SHUFPD $7, (R11), X11                   // 66450fc61b07
+       SHUFPD $7, X2, X11                      // 66440fc6da07
+       SHUFPD $7, X11, X11                     // 66450fc6db07
+       SHUFPS $7, (BX), X2                     // 0fc61307
+       SHUFPS $7, (R11), X2                    // 410fc61307
+       SHUFPS $7, X2, X2                       // 0fc6d207
+       SHUFPS $7, X11, X2                      // 410fc6d307
+       SHUFPS $7, (BX), X11                    // 440fc61b07
+       SHUFPS $7, (R11), X11                   // 450fc61b07
+       SHUFPS $7, X2, X11                      // 440fc6da07
+       SHUFPS $7, X11, X11                     // 450fc6db07
+       //TODO: SIDT (BX)                       // 0f010b
+       //TODO: SIDT (R11)                      // 410f010b
+       //TODO: SLDTW (BX)                      // 660f0003
+       //TODO: SLDTW (R11)                     // 66410f0003
+       //TODO: SLDTW DX                        // 660f00c2
+       //TODO: SLDTW R11                       // 66410f00c3
+       //TODO: SLDTL (BX)                      // 0f0003
+       //TODO: SLDTL (R11)                     // 410f0003
+       //TODO: SLDTL DX                        // 0f00c2
+       //TODO: SLDTL R11                       // 410f00c3
+       //TODO: SLDTQ (BX)                      // 480f0003
+       //TODO: SLDTQ (R11)                     // 490f0003
+       //TODO: SLDTQ DX                        // 480f00c2
+       //TODO: SLDTQ R11                       // 490f00c3
+       //TODO: SMSWW (BX)                      // 660f0123
+       //TODO: SMSWW (R11)                     // 66410f0123
+       //TODO: SMSWW DX                        // 660f01e2
+       //TODO: SMSWW R11                       // 66410f01e3
+       //TODO: SMSWL (BX)                      // 0f0123
+       //TODO: SMSWL (R11)                     // 410f0123
+       //TODO: SMSWL DX                        // 0f01e2
+       //TODO: SMSWL R11                       // 410f01e3
+       //TODO: SMSWQ (BX)                      // 480f0123
+       //TODO: SMSWQ (R11)                     // 490f0123
+       //TODO: SMSWQ DX                        // 480f01e2
+       //TODO: SMSWQ R11                       // 490f01e3
+       SQRTPD (BX), X2                         // 660f5113
+       SQRTPD (R11), X2                        // 66410f5113
+       SQRTPD X2, X2                           // 660f51d2
+       SQRTPD X11, X2                          // 66410f51d3
+       SQRTPD (BX), X11                        // 66440f511b
+       SQRTPD (R11), X11                       // 66450f511b
+       SQRTPD X2, X11                          // 66440f51da
+       SQRTPD X11, X11                         // 66450f51db
+       SQRTPS (BX), X2                         // 0f5113
+       SQRTPS (R11), X2                        // 410f5113
+       SQRTPS X2, X2                           // 0f51d2
+       SQRTPS X11, X2                          // 410f51d3
+       SQRTPS (BX), X11                        // 440f511b
+       SQRTPS (R11), X11                       // 450f511b
+       SQRTPS X2, X11                          // 440f51da
+       SQRTPS X11, X11                         // 450f51db
+       SQRTSD (BX), X2                         // f20f5113
+       SQRTSD (R11), X2                        // f2410f5113
+       SQRTSD X2, X2                           // f20f51d2
+       SQRTSD X11, X2                          // f2410f51d3
+       SQRTSD (BX), X11                        // f2440f511b
+       SQRTSD (R11), X11                       // f2450f511b
+       SQRTSD X2, X11                          // f2440f51da
+       SQRTSD X11, X11                         // f2450f51db
+       SQRTSS (BX), X2                         // f30f5113
+       SQRTSS (R11), X2                        // f3410f5113
+       SQRTSS X2, X2                           // f30f51d2
+       SQRTSS X11, X2                          // f3410f51d3
+       SQRTSS (BX), X11                        // f3440f511b
+       SQRTSS (R11), X11                       // f3450f511b
+       SQRTSS X2, X11                          // f3440f51da
+       SQRTSS X11, X11                         // f3450f51db
+       //TODO: STAC                            // 0f01cb
+       STC                                     // f9
+       STD                                     // fd
+       STI                                     // fb
+       STMXCSR (BX)                            // 0fae1b
+       STMXCSR (R11)                           // 410fae1b
+       STOSB                                   // aa
+       STOSL                                   // ab
+       STOSQ                                   // 48ab
+       STOSW                                   // 66ab
+       //TODO: STRW (BX)                       // 660f000b
+       //TODO: STRW (R11)                      // 66410f000b
+       //TODO: STRW DX                         // 660f00ca
+       //TODO: STRW R11                        // 66410f00cb
+       //TODO: STRL (BX)                       // 0f000b
+       //TODO: STRL (R11)                      // 410f000b
+       //TODO: STRL DX                         // 0f00ca
+       //TODO: STRL R11                        // 410f00cb
+       //TODO: STRQ (BX)                       // 480f000b
+       //TODO: STRQ (R11)                      // 490f000b
+       //TODO: STRQ DX                         // 480f00ca
+       //TODO: STRQ R11                        // 490f00cb
+       SUBB $7, AL                             // 2c07
+       SUBW $61731, AX                         // 662d23f1
+       SUBL $4045620583, AX                    // 2d674523f1
+       SUBQ $-249346713, AX                    // 482d674523f1
+       SUBW $61731, (BX)                       // 66812b23f1
+       SUBW $61731, (R11)                      // 6641812b23f1
+       SUBW $61731, DX                         // 6681ea23f1
+       SUBW $61731, R11                        // 664181eb23f1
+       SUBW $7, (BX)                           // 66832b07
+       SUBW $7, (R11)                          // 6641832b07
+       SUBW $7, DX                             // 6683ea07
+       SUBW $7, R11                            // 664183eb07
+       SUBW DX, (BX)                           // 662913
+       SUBW R11, (BX)                          // 6644291b
+       SUBW DX, (R11)                          // 66412913
+       SUBW R11, (R11)                         // 6645291b
+       SUBW DX, DX                             // 6629d2 or 662bd2
+       SUBW R11, DX                            // 664429da or 66412bd3
+       SUBW DX, R11                            // 664129d3 or 66442bda
+       SUBW R11, R11                           // 664529db or 66452bdb
+       SUBL $4045620583, (BX)                  // 812b674523f1
+       SUBL $4045620583, (R11)                 // 41812b674523f1
+       SUBL $4045620583, DX                    // 81ea674523f1
+       SUBL $4045620583, R11                   // 4181eb674523f1
+       SUBL $7, (BX)                           // 832b07
+       SUBL $7, (R11)                          // 41832b07
+       SUBL $7, DX                             // 83ea07
+       SUBL $7, R11                            // 4183eb07
+       SUBL DX, (BX)                           // 2913
+       SUBL R11, (BX)                          // 44291b
+       SUBL DX, (R11)                          // 412913
+       SUBL R11, (R11)                         // 45291b
+       SUBL DX, DX                             // 29d2 or 2bd2
+       SUBL R11, DX                            // 4429da or 412bd3
+       SUBL DX, R11                            // 4129d3 or 442bda
+       SUBL R11, R11                           // 4529db or 452bdb
+       SUBQ $-249346713, (BX)                  // 48812b674523f1
+       SUBQ $-249346713, (R11)                 // 49812b674523f1
+       SUBQ $-249346713, DX                    // 4881ea674523f1
+       SUBQ $-249346713, R11                   // 4981eb674523f1
+       SUBQ $7, (BX)                           // 48832b07
+       SUBQ $7, (R11)                          // 49832b07
+       SUBQ $7, DX                             // 4883ea07
+       SUBQ $7, R11                            // 4983eb07
+       SUBQ DX, (BX)                           // 482913
+       SUBQ R11, (BX)                          // 4c291b
+       SUBQ DX, (R11)                          // 492913
+       SUBQ R11, (R11)                         // 4d291b
+       SUBQ DX, DX                             // 4829d2 or 482bd2
+       SUBQ R11, DX                            // 4c29da or 492bd3
+       SUBQ DX, R11                            // 4929d3 or 4c2bda
+       SUBQ R11, R11                           // 4d29db or 4d2bdb
+       SUBB $7, (BX)                           // 802b07
+       SUBB $7, (R11)                          // 41802b07
+       SUBB $7, DL                             // 80ea07
+       SUBB $7, R11                            // 4180eb07
+       SUBB DL, (BX)                           // 2813
+       SUBB R11, (BX)                          // 44281b
+       SUBB DL, (R11)                          // 412813
+       SUBB R11, (R11)                         // 45281b
+       SUBB DL, DL                             // 28d2 or 2ad2
+       SUBB R11, DL                            // 4428da or 412ad3
+       SUBB DL, R11                            // 4128d3 or 442ada
+       SUBB R11, R11                           // 4528db or 452adb
+       SUBW (BX), DX                           // 662b13
+       SUBW (R11), DX                          // 66412b13
+       SUBW (BX), R11                          // 66442b1b
+       SUBW (R11), R11                         // 66452b1b
+       SUBL (BX), DX                           // 2b13
+       SUBL (R11), DX                          // 412b13
+       SUBL (BX), R11                          // 442b1b
+       SUBL (R11), R11                         // 452b1b
+       SUBQ (BX), DX                           // 482b13
+       SUBQ (R11), DX                          // 492b13
+       SUBQ (BX), R11                          // 4c2b1b
+       SUBQ (R11), R11                         // 4d2b1b
+       SUBB (BX), DL                           // 2a13
+       SUBB (R11), DL                          // 412a13
+       SUBB (BX), R11                          // 442a1b
+       SUBB (R11), R11                         // 452a1b
+       SUBPD (BX), X2                          // 660f5c13
+       SUBPD (R11), X2                         // 66410f5c13
+       SUBPD X2, X2                            // 660f5cd2
+       SUBPD X11, X2                           // 66410f5cd3
+       SUBPD (BX), X11                         // 66440f5c1b
+       SUBPD (R11), X11                        // 66450f5c1b
+       SUBPD X2, X11                           // 66440f5cda
+       SUBPD X11, X11                          // 66450f5cdb
+       SUBPS (BX), X2                          // 0f5c13
+       SUBPS (R11), X2                         // 410f5c13
+       SUBPS X2, X2                            // 0f5cd2
+       SUBPS X11, X2                           // 410f5cd3
+       SUBPS (BX), X11                         // 440f5c1b
+       SUBPS (R11), X11                        // 450f5c1b
+       SUBPS X2, X11                           // 440f5cda
+       SUBPS X11, X11                          // 450f5cdb
+       SUBSD (BX), X2                          // f20f5c13
+       SUBSD (R11), X2                         // f2410f5c13
+       SUBSD X2, X2                            // f20f5cd2
+       SUBSD X11, X2                           // f2410f5cd3
+       SUBSD (BX), X11                         // f2440f5c1b
+       SUBSD (R11), X11                        // f2450f5c1b
+       SUBSD X2, X11                           // f2440f5cda
+       SUBSD X11, X11                          // f2450f5cdb
+       SUBSS (BX), X2                          // f30f5c13
+       SUBSS (R11), X2                         // f3410f5c13
+       SUBSS X2, X2                            // f30f5cd2
+       SUBSS X11, X2                           // f3410f5cd3
+       SUBSS (BX), X11                         // f3440f5c1b
+       SUBSS (R11), X11                        // f3450f5c1b
+       SUBSS X2, X11                           // f3440f5cda
+       SUBSS X11, X11                          // f3450f5cdb
+       SWAPGS                                  // 0f01f8
+       SYSCALL                                 // 0f05
+       //TODO: SYSENTER                        // 0f34
+       //TODO: SYSEXIT                         // 0f35
+       SYSRET                                  // 0f07
+       TESTB $7, AL                            // a807
+       TESTW $61731, AX                        // 66a923f1
+       TESTL $4045620583, AX                   // a9674523f1
+       TESTQ $-249346713, AX                   // 48a9674523f1
+       TESTW $61731, (BX)                      // 66f70323f1
+       TESTW $61731, (R11)                     // 6641f70323f1
+       TESTW $61731, DX                        // 66f7c223f1
+       TESTW $61731, R11                       // 6641f7c323f1
+       TESTW DX, (BX)                          // 668513
+       TESTW R11, (BX)                         // 6644851b
+       TESTW DX, (R11)                         // 66418513
+       TESTW R11, (R11)                        // 6645851b
+       TESTW DX, DX                            // 6685d2
+       TESTW R11, DX                           // 664485da
+       TESTW DX, R11                           // 664185d3
+       TESTW R11, R11                          // 664585db
+       TESTL $4045620583, (BX)                 // f703674523f1
+       TESTL $4045620583, (R11)                // 41f703674523f1
+       TESTL $4045620583, DX                   // f7c2674523f1
+       TESTL $4045620583, R11                  // 41f7c3674523f1
+       TESTL DX, (BX)                          // 8513
+       TESTL R11, (BX)                         // 44851b
+       TESTL DX, (R11)                         // 418513
+       TESTL R11, (R11)                        // 45851b
+       TESTL DX, DX                            // 85d2
+       TESTL R11, DX                           // 4485da
+       TESTL DX, R11                           // 4185d3
+       TESTL R11, R11                          // 4585db
+       TESTQ $-249346713, (BX)                 // 48f703674523f1
+       TESTQ $-249346713, (R11)                // 49f703674523f1
+       TESTQ $-249346713, DX                   // 48f7c2674523f1
+       TESTQ $-249346713, R11                  // 49f7c3674523f1
+       TESTQ DX, (BX)                          // 488513
+       TESTQ R11, (BX)                         // 4c851b
+       TESTQ DX, (R11)                         // 498513
+       TESTQ R11, (R11)                        // 4d851b
+       TESTQ DX, DX                            // 4885d2
+       TESTQ R11, DX                           // 4c85da
+       TESTQ DX, R11                           // 4985d3
+       TESTQ R11, R11                          // 4d85db
+       TESTB $7, (BX)                          // f60307
+       TESTB $7, (R11)                         // 41f60307
+       TESTB $7, DL                            // f6c207
+       TESTB $7, R11                           // 41f6c307
+       TESTB DL, (BX)                          // 8413
+       TESTB R11, (BX)                         // 44841b
+       TESTB DL, (R11)                         // 418413
+       TESTB R11, (R11)                        // 45841b
+       TESTB DL, DL                            // 84d2
+       TESTB R11, DL                           // 4484da
+       TESTB DL, R11                           // 4184d3
+       TESTB R11, R11                          // 4584db
+       //TODO: TZCNTW (BX), DX                 // 66f30fbc13
+       //TODO: TZCNTW (R11), DX                // 66f3410fbc13
+       //TODO: TZCNTW DX, DX                   // 66f30fbcd2
+       //TODO: TZCNTW R11, DX                  // 66f3410fbcd3
+       //TODO: TZCNTW (BX), R11                // 66f3440fbc1b
+       //TODO: TZCNTW (R11), R11               // 66f3450fbc1b
+       //TODO: TZCNTW DX, R11                  // 66f3440fbcda
+       //TODO: TZCNTW R11, R11                 // 66f3450fbcdb
+       //TODO: TZCNTL (BX), DX                 // f30fbc13
+       //TODO: TZCNTL (R11), DX                // f3410fbc13
+       //TODO: TZCNTL DX, DX                   // f30fbcd2
+       //TODO: TZCNTL R11, DX                  // f3410fbcd3
+       //TODO: TZCNTL (BX), R11                // f3440fbc1b
+       //TODO: TZCNTL (R11), R11               // f3450fbc1b
+       //TODO: TZCNTL DX, R11                  // f3440fbcda
+       //TODO: TZCNTL R11, R11                 // f3450fbcdb
+       //TODO: TZCNTQ (BX), DX                 // f3480fbc13
+       //TODO: TZCNTQ (R11), DX                // f3490fbc13
+       //TODO: TZCNTQ DX, DX                   // f3480fbcd2
+       //TODO: TZCNTQ R11, DX                  // f3490fbcd3
+       //TODO: TZCNTQ (BX), R11                // f34c0fbc1b
+       //TODO: TZCNTQ (R11), R11               // f34d0fbc1b
+       //TODO: TZCNTQ DX, R11                  // f34c0fbcda
+       //TODO: TZCNTQ R11, R11                 // f34d0fbcdb
+       UCOMISD (BX), X2                        // 660f2e13
+       UCOMISD (R11), X2                       // 66410f2e13
+       UCOMISD X2, X2                          // 660f2ed2
+       UCOMISD X11, X2                         // 66410f2ed3
+       UCOMISD (BX), X11                       // 66440f2e1b
+       UCOMISD (R11), X11                      // 66450f2e1b
+       UCOMISD X2, X11                         // 66440f2eda
+       UCOMISD X11, X11                        // 66450f2edb
+       UCOMISS (BX), X2                        // 0f2e13
+       UCOMISS (R11), X2                       // 410f2e13
+       UCOMISS X2, X2                          // 0f2ed2
+       UCOMISS X11, X2                         // 410f2ed3
+       UCOMISS (BX), X11                       // 440f2e1b
+       UCOMISS (R11), X11                      // 450f2e1b
+       UCOMISS X2, X11                         // 440f2eda
+       UCOMISS X11, X11                        // 450f2edb
+       //TODO: UD1                             // 0fb9
+       //TODO: UD2                             // 0f0b
+       UNPCKHPD (BX), X2                       // 660f1513
+       UNPCKHPD (R11), X2                      // 66410f1513
+       UNPCKHPD X2, X2                         // 660f15d2
+       UNPCKHPD X11, X2                        // 66410f15d3
+       UNPCKHPD (BX), X11                      // 66440f151b
+       UNPCKHPD (R11), X11                     // 66450f151b
+       UNPCKHPD X2, X11                        // 66440f15da
+       UNPCKHPD X11, X11                       // 66450f15db
+       UNPCKHPS (BX), X2                       // 0f1513
+       UNPCKHPS (R11), X2                      // 410f1513
+       UNPCKHPS X2, X2                         // 0f15d2
+       UNPCKHPS X11, X2                        // 410f15d3
+       UNPCKHPS (BX), X11                      // 440f151b
+       UNPCKHPS (R11), X11                     // 450f151b
+       UNPCKHPS X2, X11                        // 440f15da
+       UNPCKHPS X11, X11                       // 450f15db
+       UNPCKLPD (BX), X2                       // 660f1413
+       UNPCKLPD (R11), X2                      // 66410f1413
+       UNPCKLPD X2, X2                         // 660f14d2
+       UNPCKLPD X11, X2                        // 66410f14d3
+       UNPCKLPD (BX), X11                      // 66440f141b
+       UNPCKLPD (R11), X11                     // 66450f141b
+       UNPCKLPD X2, X11                        // 66440f14da
+       UNPCKLPD X11, X11                       // 66450f14db
+       UNPCKLPS (BX), X2                       // 0f1413
+       UNPCKLPS (R11), X2                      // 410f1413
+       UNPCKLPS X2, X2                         // 0f14d2
+       UNPCKLPS X11, X2                        // 410f14d3
+       UNPCKLPS (BX), X11                      // 440f141b
+       UNPCKLPS (R11), X11                     // 450f141b
+       UNPCKLPS X2, X11                        // 440f14da
+       UNPCKLPS X11, X11                       // 450f14db
+       //TODO: VADDPD (BX), X9, X2             // c4e1315813 or c5b15813
+       //TODO: VADDPD (R11), X9, X2            // c4c1315813
+       //TODO: VADDPD X2, X9, X2               // c4e13158d2 or c5b158d2
+       //TODO: VADDPD X11, X9, X2              // c4c13158d3
+       //TODO: VADDPD (BX), X9, X11            // c46131581b or c531581b
+       //TODO: VADDPD (R11), X9, X11           // c44131581b
+       //TODO: VADDPD X2, X9, X11              // c4613158da or c53158da
+       //TODO: VADDPD X11, X9, X11             // c4413158db
+       //TODO: VADDPD (BX), Y15, Y2            // c4e1055813 or c5855813
+       //TODO: VADDPD (R11), Y15, Y2           // c4c1055813
+       //TODO: VADDPD Y2, Y15, Y2              // c4e10558d2 or c58558d2
+       //TODO: VADDPD Y11, Y15, Y2             // c4c10558d3
+       //TODO: VADDPD (BX), Y15, Y11           // c46105581b or c505581b
+       //TODO: VADDPD (R11), Y15, Y11          // c44105581b
+       //TODO: VADDPD Y2, Y15, Y11             // c4610558da or c50558da
+       //TODO: VADDPD Y11, Y15, Y11            // c4410558db
+       //TODO: VADDPS (BX), X9, X2             // c4e1305813 or c5b05813
+       //TODO: VADDPS (R11), X9, X2            // c4c1305813
+       //TODO: VADDPS X2, X9, X2               // c4e13058d2 or c5b058d2
+       //TODO: VADDPS X11, X9, X2              // c4c13058d3
+       //TODO: VADDPS (BX), X9, X11            // c46130581b or c530581b
+       //TODO: VADDPS (R11), X9, X11           // c44130581b
+       //TODO: VADDPS X2, X9, X11              // c4613058da or c53058da
+       //TODO: VADDPS X11, X9, X11             // c4413058db
+       //TODO: VADDPS (BX), Y15, Y2            // c4e1045813 or c5845813
+       //TODO: VADDPS (R11), Y15, Y2           // c4c1045813
+       //TODO: VADDPS Y2, Y15, Y2              // c4e10458d2 or c58458d2
+       //TODO: VADDPS Y11, Y15, Y2             // c4c10458d3
+       //TODO: VADDPS (BX), Y15, Y11           // c46104581b or c504581b
+       //TODO: VADDPS (R11), Y15, Y11          // c44104581b
+       //TODO: VADDPS Y2, Y15, Y11             // c4610458da or c50458da
+       //TODO: VADDPS Y11, Y15, Y11            // c4410458db
+       //TODO: VADDSD (BX), X9, X2             // c4e1335813 or c5b35813
+       //TODO: VADDSD (R11), X9, X2            // c4c1335813
+       //TODO: VADDSD X2, X9, X2               // c4e13358d2 or c5b358d2
+       //TODO: VADDSD X11, X9, X2              // c4c13358d3
+       //TODO: VADDSD (BX), X9, X11            // c46133581b or c533581b
+       //TODO: VADDSD (R11), X9, X11           // c44133581b
+       //TODO: VADDSD X2, X9, X11              // c4613358da or c53358da
+       //TODO: VADDSD X11, X9, X11             // c4413358db
+       //TODO: VADDSS (BX), X9, X2             // c4e1325813 or c5b25813
+       //TODO: VADDSS (R11), X9, X2            // c4c1325813
+       //TODO: VADDSS X2, X9, X2               // c4e13258d2 or c5b258d2
+       //TODO: VADDSS X11, X9, X2              // c4c13258d3
+       //TODO: VADDSS (BX), X9, X11            // c46132581b or c532581b
+       //TODO: VADDSS (R11), X9, X11           // c44132581b
+       //TODO: VADDSS X2, X9, X11              // c4613258da or c53258da
+       //TODO: VADDSS X11, X9, X11             // c4413258db
+       //TODO: VADDSUBPD (BX), X9, X2          // c4e131d013 or c5b1d013
+       //TODO: VADDSUBPD (R11), X9, X2         // c4c131d013
+       //TODO: VADDSUBPD X2, X9, X2            // c4e131d0d2 or c5b1d0d2
+       //TODO: VADDSUBPD X11, X9, X2           // c4c131d0d3
+       //TODO: VADDSUBPD (BX), X9, X11         // c46131d01b or c531d01b
+       //TODO: VADDSUBPD (R11), X9, X11        // c44131d01b
+       //TODO: VADDSUBPD X2, X9, X11           // c46131d0da or c531d0da
+       //TODO: VADDSUBPD X11, X9, X11          // c44131d0db
+       //TODO: VADDSUBPD (BX), Y15, Y2         // c4e105d013 or c585d013
+       //TODO: VADDSUBPD (R11), Y15, Y2        // c4c105d013
+       //TODO: VADDSUBPD Y2, Y15, Y2           // c4e105d0d2 or c585d0d2
+       //TODO: VADDSUBPD Y11, Y15, Y2          // c4c105d0d3
+       //TODO: VADDSUBPD (BX), Y15, Y11        // c46105d01b or c505d01b
+       //TODO: VADDSUBPD (R11), Y15, Y11       // c44105d01b
+       //TODO: VADDSUBPD Y2, Y15, Y11          // c46105d0da or c505d0da
+       //TODO: VADDSUBPD Y11, Y15, Y11         // c44105d0db
+       //TODO: VADDSUBPS (BX), X9, X2          // c4e133d013 or c5b3d013
+       //TODO: VADDSUBPS (R11), X9, X2         // c4c133d013
+       //TODO: VADDSUBPS X2, X9, X2            // c4e133d0d2 or c5b3d0d2
+       //TODO: VADDSUBPS X11, X9, X2           // c4c133d0d3
+       //TODO: VADDSUBPS (BX), X9, X11         // c46133d01b or c533d01b
+       //TODO: VADDSUBPS (R11), X9, X11        // c44133d01b
+       //TODO: VADDSUBPS X2, X9, X11           // c46133d0da or c533d0da
+       //TODO: VADDSUBPS X11, X9, X11          // c44133d0db
+       //TODO: VADDSUBPS (BX), Y15, Y2         // c4e107d013 or c587d013
+       //TODO: VADDSUBPS (R11), Y15, Y2        // c4c107d013
+       //TODO: VADDSUBPS Y2, Y15, Y2           // c4e107d0d2 or c587d0d2
+       //TODO: VADDSUBPS Y11, Y15, Y2          // c4c107d0d3
+       //TODO: VADDSUBPS (BX), Y15, Y11        // c46107d01b or c507d01b
+       //TODO: VADDSUBPS (R11), Y15, Y11       // c44107d01b
+       //TODO: VADDSUBPS Y2, Y15, Y11          // c46107d0da or c507d0da
+       //TODO: VADDSUBPS Y11, Y15, Y11         // c44107d0db
+       //TODO: VAESDEC (BX), X9, X2            // c4e231de13
+       //TODO: VAESDEC (R11), X9, X2           // c4c231de13
+       //TODO: VAESDEC X2, X9, X2              // c4e231ded2
+       //TODO: VAESDEC X11, X9, X2             // c4c231ded3
+       //TODO: VAESDEC (BX), X9, X11           // c46231de1b
+       //TODO: VAESDEC (R11), X9, X11          // c44231de1b
+       //TODO: VAESDEC X2, X9, X11             // c46231deda
+       //TODO: VAESDEC X11, X9, X11            // c44231dedb
+       //TODO: VAESDECLAST (BX), X9, X2        // c4e231df13
+       //TODO: VAESDECLAST (R11), X9, X2       // c4c231df13
+       //TODO: VAESDECLAST X2, X9, X2          // c4e231dfd2
+       //TODO: VAESDECLAST X11, X9, X2         // c4c231dfd3
+       //TODO: VAESDECLAST (BX), X9, X11       // c46231df1b
+       //TODO: VAESDECLAST (R11), X9, X11      // c44231df1b
+       //TODO: VAESDECLAST X2, X9, X11         // c46231dfda
+       //TODO: VAESDECLAST X11, X9, X11        // c44231dfdb
+       //TODO: VAESENC (BX), X9, X2            // c4e231dc13
+       //TODO: VAESENC (R11), X9, X2           // c4c231dc13
+       //TODO: VAESENC X2, X9, X2              // c4e231dcd2
+       //TODO: VAESENC X11, X9, X2             // c4c231dcd3
+       //TODO: VAESENC (BX), X9, X11           // c46231dc1b
+       //TODO: VAESENC (R11), X9, X11          // c44231dc1b
+       //TODO: VAESENC X2, X9, X11             // c46231dcda
+       //TODO: VAESENC X11, X9, X11            // c44231dcdb
+       //TODO: VAESENCLAST (BX), X9, X2        // c4e231dd13
+       //TODO: VAESENCLAST (R11), X9, X2       // c4c231dd13
+       //TODO: VAESENCLAST X2, X9, X2          // c4e231ddd2
+       //TODO: VAESENCLAST X11, X9, X2         // c4c231ddd3
+       //TODO: VAESENCLAST (BX), X9, X11       // c46231dd1b
+       //TODO: VAESENCLAST (R11), X9, X11      // c44231dd1b
+       //TODO: VAESENCLAST X2, X9, X11         // c46231ddda
+       //TODO: VAESENCLAST X11, X9, X11        // c44231dddb
+       //TODO: VAESIMC (BX), X2                // c4e279db13
+       //TODO: VAESIMC (R11), X2               // c4c279db13
+       //TODO: VAESIMC X2, X2                  // c4e279dbd2
+       //TODO: VAESIMC X11, X2                 // c4c279dbd3
+       //TODO: VAESIMC (BX), X11               // c46279db1b
+       //TODO: VAESIMC (R11), X11              // c44279db1b
+       //TODO: VAESIMC X2, X11                 // c46279dbda
+       //TODO: VAESIMC X11, X11                // c44279dbdb
+       //TODO: VAESKEYGENASSIST $7, (BX), X2   // c4e379df1307
+       //TODO: VAESKEYGENASSIST $7, (R11), X2  // c4c379df1307
+       //TODO: VAESKEYGENASSIST $7, X2, X2     // c4e379dfd207
+       //TODO: VAESKEYGENASSIST $7, X11, X2    // c4c379dfd307
+       //TODO: VAESKEYGENASSIST $7, (BX), X11  // c46379df1b07
+       //TODO: VAESKEYGENASSIST $7, (R11), X11 // c44379df1b07
+       //TODO: VAESKEYGENASSIST $7, X2, X11    // c46379dfda07
+       //TODO: VAESKEYGENASSIST $7, X11, X11   // c44379dfdb07
+       //TODO: VANDNPD (BX), X9, X2            // c4e1315513 or c5b15513
+       //TODO: VANDNPD (R11), X9, X2           // c4c1315513
+       //TODO: VANDNPD X2, X9, X2              // c4e13155d2 or c5b155d2
+       //TODO: VANDNPD X11, X9, X2             // c4c13155d3
+       //TODO: VANDNPD (BX), X9, X11           // c46131551b or c531551b
+       //TODO: VANDNPD (R11), X9, X11          // c44131551b
+       //TODO: VANDNPD X2, X9, X11             // c4613155da or c53155da
+       //TODO: VANDNPD X11, X9, X11            // c4413155db
+       //TODO: VANDNPD (BX), Y15, Y2           // c4e1055513 or c5855513
+       //TODO: VANDNPD (R11), Y15, Y2          // c4c1055513
+       //TODO: VANDNPD Y2, Y15, Y2             // c4e10555d2 or c58555d2
+       //TODO: VANDNPD Y11, Y15, Y2            // c4c10555d3
+       //TODO: VANDNPD (BX), Y15, Y11          // c46105551b or c505551b
+       //TODO: VANDNPD (R11), Y15, Y11         // c44105551b
+       //TODO: VANDNPD Y2, Y15, Y11            // c4610555da or c50555da
+       //TODO: VANDNPD Y11, Y15, Y11           // c4410555db
+       //TODO: VANDNPS (BX), X9, X2            // c4e1305513 or c5b05513
+       //TODO: VANDNPS (R11), X9, X2           // c4c1305513
+       //TODO: VANDNPS X2, X9, X2              // c4e13055d2 or c5b055d2
+       //TODO: VANDNPS X11, X9, X2             // c4c13055d3
+       //TODO: VANDNPS (BX), X9, X11           // c46130551b or c530551b
+       //TODO: VANDNPS (R11), X9, X11          // c44130551b
+       //TODO: VANDNPS X2, X9, X11             // c4613055da or c53055da
+       //TODO: VANDNPS X11, X9, X11            // c4413055db
+       //TODO: VANDNPS (BX), Y15, Y2           // c4e1045513 or c5845513
+       //TODO: VANDNPS (R11), Y15, Y2          // c4c1045513
+       //TODO: VANDNPS Y2, Y15, Y2             // c4e10455d2 or c58455d2
+       //TODO: VANDNPS Y11, Y15, Y2            // c4c10455d3
+       //TODO: VANDNPS (BX), Y15, Y11          // c46104551b or c504551b
+       //TODO: VANDNPS (R11), Y15, Y11         // c44104551b
+       //TODO: VANDNPS Y2, Y15, Y11            // c4610455da or c50455da
+       //TODO: VANDNPS Y11, Y15, Y11           // c4410455db
+       //TODO: VANDPD (BX), X9, X2             // c4e1315413 or c5b15413
+       //TODO: VANDPD (R11), X9, X2            // c4c1315413
+       //TODO: VANDPD X2, X9, X2               // c4e13154d2 or c5b154d2
+       //TODO: VANDPD X11, X9, X2              // c4c13154d3
+       //TODO: VANDPD (BX), X9, X11            // c46131541b or c531541b
+       //TODO: VANDPD (R11), X9, X11           // c44131541b
+       //TODO: VANDPD X2, X9, X11              // c4613154da or c53154da
+       //TODO: VANDPD X11, X9, X11             // c4413154db
+       //TODO: VANDPD (BX), Y15, Y2            // c4e1055413 or c5855413
+       //TODO: VANDPD (R11), Y15, Y2           // c4c1055413
+       //TODO: VANDPD Y2, Y15, Y2              // c4e10554d2 or c58554d2
+       //TODO: VANDPD Y11, Y15, Y2             // c4c10554d3
+       //TODO: VANDPD (BX), Y15, Y11           // c46105541b or c505541b
+       //TODO: VANDPD (R11), Y15, Y11          // c44105541b
+       //TODO: VANDPD Y2, Y15, Y11             // c4610554da or c50554da
+       //TODO: VANDPD Y11, Y15, Y11            // c4410554db
+       //TODO: VANDPS (BX), X9, X2             // c4e1305413 or c5b05413
+       //TODO: VANDPS (R11), X9, X2            // c4c1305413
+       //TODO: VANDPS X2, X9, X2               // c4e13054d2 or c5b054d2
+       //TODO: VANDPS X11, X9, X2              // c4c13054d3
+       //TODO: VANDPS (BX), X9, X11            // c46130541b or c530541b
+       //TODO: VANDPS (R11), X9, X11           // c44130541b
+       //TODO: VANDPS X2, X9, X11              // c4613054da or c53054da
+       //TODO: VANDPS X11, X9, X11             // c4413054db
+       //TODO: VANDPS (BX), Y15, Y2            // c4e1045413 or c5845413
+       //TODO: VANDPS (R11), Y15, Y2           // c4c1045413
+       //TODO: VANDPS Y2, Y15, Y2              // c4e10454d2 or c58454d2
+       //TODO: VANDPS Y11, Y15, Y2             // c4c10454d3
+       //TODO: VANDPS (BX), Y15, Y11           // c46104541b or c504541b
+       //TODO: VANDPS (R11), Y15, Y11          // c44104541b
+       //TODO: VANDPS Y2, Y15, Y11             // c4610454da or c50454da
+       //TODO: VANDPS Y11, Y15, Y11            // c4410454db
+       //TODO: VBLENDPD $7, (BX), X9, X2       // c4e3310d1307
+       //TODO: VBLENDPD $7, (R11), X9, X2      // c4c3310d1307
+       //TODO: VBLENDPD $7, X2, X9, X2         // c4e3310dd207
+       //TODO: VBLENDPD $7, X11, X9, X2        // c4c3310dd307
+       //TODO: VBLENDPD $7, (BX), X9, X11      // c463310d1b07
+       //TODO: VBLENDPD $7, (R11), X9, X11     // c443310d1b07
+       //TODO: VBLENDPD $7, X2, X9, X11        // c463310dda07
+       //TODO: VBLENDPD $7, X11, X9, X11       // c443310ddb07
+       //TODO: VBLENDPD $7, (BX), Y15, Y2      // c4e3050d1307
+       //TODO: VBLENDPD $7, (R11), Y15, Y2     // c4c3050d1307
+       //TODO: VBLENDPD $7, Y2, Y15, Y2        // c4e3050dd207
+       //TODO: VBLENDPD $7, Y11, Y15, Y2       // c4c3050dd307
+       //TODO: VBLENDPD $7, (BX), Y15, Y11     // c463050d1b07
+       //TODO: VBLENDPD $7, (R11), Y15, Y11    // c443050d1b07
+       //TODO: VBLENDPD $7, Y2, Y15, Y11       // c463050dda07
+       //TODO: VBLENDPD $7, Y11, Y15, Y11      // c443050ddb07
+       //TODO: VBLENDPS $7, (BX), X9, X2       // c4e3310c1307
+       //TODO: VBLENDPS $7, (R11), X9, X2      // c4c3310c1307
+       //TODO: VBLENDPS $7, X2, X9, X2         // c4e3310cd207
+       //TODO: VBLENDPS $7, X11, X9, X2        // c4c3310cd307
+       //TODO: VBLENDPS $7, (BX), X9, X11      // c463310c1b07
+       //TODO: VBLENDPS $7, (R11), X9, X11     // c443310c1b07
+       //TODO: VBLENDPS $7, X2, X9, X11        // c463310cda07
+       //TODO: VBLENDPS $7, X11, X9, X11       // c443310cdb07
+       //TODO: VBLENDPS $7, (BX), Y15, Y2      // c4e3050c1307
+       //TODO: VBLENDPS $7, (R11), Y15, Y2     // c4c3050c1307
+       //TODO: VBLENDPS $7, Y2, Y15, Y2        // c4e3050cd207
+       //TODO: VBLENDPS $7, Y11, Y15, Y2       // c4c3050cd307
+       //TODO: VBLENDPS $7, (BX), Y15, Y11     // c463050c1b07
+       //TODO: VBLENDPS $7, (R11), Y15, Y11    // c443050c1b07
+       //TODO: VBLENDPS $7, Y2, Y15, Y11       // c463050cda07
+       //TODO: VBLENDPS $7, Y11, Y15, Y11      // c443050cdb07
+       //TODO: VBLENDVPD XMM12, (BX), X9, X2   // c4e3314b13c0
+       //TODO: VBLENDVPD XMM12, (R11), X9, X2  // c4c3314b13c0
+       //TODO: VBLENDVPD XMM12, X2, X9, X2     // c4e3314bd2c0
+       //TODO: VBLENDVPD XMM12, X11, X9, X2    // c4c3314bd3c0
+       //TODO: VBLENDVPD XMM12, (BX), X9, X11  // c463314b1bc0
+       //TODO: VBLENDVPD XMM12, (R11), X9, X11 // c443314b1bc0
+       //TODO: VBLENDVPD XMM12, X2, X9, X11    // c463314bdac0
+       //TODO: VBLENDVPD XMM12, X11, X9, X11   // c443314bdbc0
+       //TODO: VBLENDVPD YMM13, (BX), Y15, Y2  // c4e3054b13d0
+       //TODO: VBLENDVPD YMM13, (R11), Y15, Y2 // c4c3054b13d0
+       //TODO: VBLENDVPD YMM13, Y2, Y15, Y2    // c4e3054bd2d0
+       //TODO: VBLENDVPD YMM13, Y11, Y15, Y2   // c4c3054bd3d0
+       //TODO: VBLENDVPD YMM13, (BX), Y15, Y11 // c463054b1bd0
+       //TODO: VBLENDVPD YMM13, (R11), Y15, Y11 // c443054b1bd0
+       //TODO: VBLENDVPD YMM13, Y2, Y15, Y11   // c463054bdad0
+       //TODO: VBLENDVPD YMM13, Y11, Y15, Y11  // c443054bdbd0
+       //TODO: VBLENDVPS XMM12, (BX), X9, X2   // c4e3314a13c0
+       //TODO: VBLENDVPS XMM12, (R11), X9, X2  // c4c3314a13c0
+       //TODO: VBLENDVPS XMM12, X2, X9, X2     // c4e3314ad2c0
+       //TODO: VBLENDVPS XMM12, X11, X9, X2    // c4c3314ad3c0
+       //TODO: VBLENDVPS XMM12, (BX), X9, X11  // c463314a1bc0
+       //TODO: VBLENDVPS XMM12, (R11), X9, X11 // c443314a1bc0
+       //TODO: VBLENDVPS XMM12, X2, X9, X11    // c463314adac0
+       //TODO: VBLENDVPS XMM12, X11, X9, X11   // c443314adbc0
+       //TODO: VBLENDVPS YMM13, (BX), Y15, Y2  // c4e3054a13d0
+       //TODO: VBLENDVPS YMM13, (R11), Y15, Y2 // c4c3054a13d0
+       //TODO: VBLENDVPS YMM13, Y2, Y15, Y2    // c4e3054ad2d0
+       //TODO: VBLENDVPS YMM13, Y11, Y15, Y2   // c4c3054ad3d0
+       //TODO: VBLENDVPS YMM13, (BX), Y15, Y11 // c463054a1bd0
+       //TODO: VBLENDVPS YMM13, (R11), Y15, Y11 // c443054a1bd0
+       //TODO: VBLENDVPS YMM13, Y2, Y15, Y11   // c463054adad0
+       //TODO: VBLENDVPS YMM13, Y11, Y15, Y11  // c443054adbd0
+       //TODO: VBROADCASTF128 (BX), Y2         // c4e27d1a13
+       //TODO: VBROADCASTF128 (R11), Y2        // c4c27d1a13
+       //TODO: VBROADCASTF128 (BX), Y11        // c4627d1a1b
+       //TODO: VBROADCASTF128 (R11), Y11       // c4427d1a1b
+       //TODO: VBROADCASTI128 (BX), Y2         // c4e27d5a13
+       //TODO: VBROADCASTI128 (R11), Y2        // c4c27d5a13
+       //TODO: VBROADCASTI128 (BX), Y11        // c4627d5a1b
+       //TODO: VBROADCASTI128 (R11), Y11       // c4427d5a1b
+       //TODO: VBROADCASTSD (BX), Y2           // c4e27d1913
+       //TODO: VBROADCASTSD (R11), Y2          // c4c27d1913
+       //TODO: VBROADCASTSD (BX), Y11          // c4627d191b
+       //TODO: VBROADCASTSD (R11), Y11         // c4427d191b
+       //TODO: VBROADCASTSD X2, Y2             // c4e27d19d2
+       //TODO: VBROADCASTSD X11, Y2            // c4c27d19d3
+       //TODO: VBROADCASTSD X2, Y11            // c4627d19da
+       //TODO: VBROADCASTSD X11, Y11           // c4427d19db
+       //TODO: VBROADCASTSS (BX), X2           // c4e2791813
+       //TODO: VBROADCASTSS (R11), X2          // c4c2791813
+       //TODO: VBROADCASTSS (BX), X11          // c46279181b
+       //TODO: VBROADCASTSS (R11), X11         // c44279181b
+       //TODO: VBROADCASTSS X2, X2             // c4e27918d2
+       //TODO: VBROADCASTSS X11, X2            // c4c27918d3
+       //TODO: VBROADCASTSS X2, X11            // c4627918da
+       //TODO: VBROADCASTSS X11, X11           // c4427918db
+       //TODO: VBROADCASTSS (BX), Y2           // c4e27d1813
+       //TODO: VBROADCASTSS (R11), Y2          // c4c27d1813
+       //TODO: VBROADCASTSS (BX), Y11          // c4627d181b
+       //TODO: VBROADCASTSS (R11), Y11         // c4427d181b
+       //TODO: VBROADCASTSS X2, Y2             // c4e27d18d2
+       //TODO: VBROADCASTSS X11, Y2            // c4c27d18d3
+       //TODO: VBROADCASTSS X2, Y11            // c4627d18da
+       //TODO: VBROADCASTSS X11, Y11           // c4427d18db
+       //TODO: VCMPPD $7, (BX), X9, X2         // c4e131c21307 or c5b1c21307
+       //TODO: VCMPPD $7, (R11), X9, X2        // c4c131c21307
+       //TODO: VCMPPD $7, X2, X9, X2           // c4e131c2d207 or c5b1c2d207
+       //TODO: VCMPPD $7, X11, X9, X2          // c4c131c2d307
+       //TODO: VCMPPD $7, (BX), X9, X11        // c46131c21b07 or c531c21b07
+       //TODO: VCMPPD $7, (R11), X9, X11       // c44131c21b07
+       //TODO: VCMPPD $7, X2, X9, X11          // c46131c2da07 or c531c2da07
+       //TODO: VCMPPD $7, X11, X9, X11         // c44131c2db07
+       //TODO: VCMPPD $7, (BX), Y15, Y2        // c4e105c21307 or c585c21307
+       //TODO: VCMPPD $7, (R11), Y15, Y2       // c4c105c21307
+       //TODO: VCMPPD $7, Y2, Y15, Y2          // c4e105c2d207 or c585c2d207
+       //TODO: VCMPPD $7, Y11, Y15, Y2         // c4c105c2d307
+       //TODO: VCMPPD $7, (BX), Y15, Y11       // c46105c21b07 or c505c21b07
+       //TODO: VCMPPD $7, (R11), Y15, Y11      // c44105c21b07
+       //TODO: VCMPPD $7, Y2, Y15, Y11         // c46105c2da07 or c505c2da07
+       //TODO: VCMPPD $7, Y11, Y15, Y11        // c44105c2db07
+       //TODO: VCMPPS $7, (BX), X9, X2         // c4e130c21307 or c5b0c21307
+       //TODO: VCMPPS $7, (R11), X9, X2        // c4c130c21307
+       //TODO: VCMPPS $7, X2, X9, X2           // c4e130c2d207 or c5b0c2d207
+       //TODO: VCMPPS $7, X11, X9, X2          // c4c130c2d307
+       //TODO: VCMPPS $7, (BX), X9, X11        // c46130c21b07 or c530c21b07
+       //TODO: VCMPPS $7, (R11), X9, X11       // c44130c21b07
+       //TODO: VCMPPS $7, X2, X9, X11          // c46130c2da07 or c530c2da07
+       //TODO: VCMPPS $7, X11, X9, X11         // c44130c2db07
+       //TODO: VCMPPS $7, (BX), Y15, Y2        // c4e104c21307 or c584c21307
+       //TODO: VCMPPS $7, (R11), Y15, Y2       // c4c104c21307
+       //TODO: VCMPPS $7, Y2, Y15, Y2          // c4e104c2d207 or c584c2d207
+       //TODO: VCMPPS $7, Y11, Y15, Y2         // c4c104c2d307
+       //TODO: VCMPPS $7, (BX), Y15, Y11       // c46104c21b07 or c504c21b07
+       //TODO: VCMPPS $7, (R11), Y15, Y11      // c44104c21b07
+       //TODO: VCMPPS $7, Y2, Y15, Y11         // c46104c2da07 or c504c2da07
+       //TODO: VCMPPS $7, Y11, Y15, Y11        // c44104c2db07
+       //TODO: VCMPSD $7, (BX), X9, X2         // c4e133c21307 or c5b3c21307
+       //TODO: VCMPSD $7, (R11), X9, X2        // c4c133c21307
+       //TODO: VCMPSD $7, X2, X9, X2           // c4e133c2d207 or c5b3c2d207
+       //TODO: VCMPSD $7, X11, X9, X2          // c4c133c2d307
+       //TODO: VCMPSD $7, (BX), X9, X11        // c46133c21b07 or c533c21b07
+       //TODO: VCMPSD $7, (R11), X9, X11       // c44133c21b07
+       //TODO: VCMPSD $7, X2, X9, X11          // c46133c2da07 or c533c2da07
+       //TODO: VCMPSD $7, X11, X9, X11         // c44133c2db07
+       //TODO: VCMPSS $7, (BX), X9, X2         // c4e132c21307 or c5b2c21307
+       //TODO: VCMPSS $7, (R11), X9, X2        // c4c132c21307
+       //TODO: VCMPSS $7, X2, X9, X2           // c4e132c2d207 or c5b2c2d207
+       //TODO: VCMPSS $7, X11, X9, X2          // c4c132c2d307
+       //TODO: VCMPSS $7, (BX), X9, X11        // c46132c21b07 or c532c21b07
+       //TODO: VCMPSS $7, (R11), X9, X11       // c44132c21b07
+       //TODO: VCMPSS $7, X2, X9, X11          // c46132c2da07 or c532c2da07
+       //TODO: VCMPSS $7, X11, X9, X11         // c44132c2db07
+       //TODO: VCOMISD (BX), X2                // c4e1792f13 or c5f92f13
+       //TODO: VCOMISD (R11), X2               // c4c1792f13
+       //TODO: VCOMISD X2, X2                  // c4e1792fd2 or c5f92fd2
+       //TODO: VCOMISD X11, X2                 // c4c1792fd3
+       //TODO: VCOMISD (BX), X11               // c461792f1b or c5792f1b
+       //TODO: VCOMISD (R11), X11              // c441792f1b
+       //TODO: VCOMISD X2, X11                 // c461792fda or c5792fda
+       //TODO: VCOMISD X11, X11                // c441792fdb
+       //TODO: VCOMISS (BX), X2                // c4e1782f13 or c5f82f13
+       //TODO: VCOMISS (R11), X2               // c4c1782f13
+       //TODO: VCOMISS X2, X2                  // c4e1782fd2 or c5f82fd2
+       //TODO: VCOMISS X11, X2                 // c4c1782fd3
+       //TODO: VCOMISS (BX), X11               // c461782f1b or c5782f1b
+       //TODO: VCOMISS (R11), X11              // c441782f1b
+       //TODO: VCOMISS X2, X11                 // c461782fda or c5782fda
+       //TODO: VCOMISS X11, X11                // c441782fdb
+       //TODO: VCVTDQ2PD (BX), X2              // c4e17ae613 or c5fae613
+       //TODO: VCVTDQ2PD (R11), X2             // c4c17ae613
+       //TODO: VCVTDQ2PD X2, X2                // c4e17ae6d2 or c5fae6d2
+       //TODO: VCVTDQ2PD X11, X2               // c4c17ae6d3
+       //TODO: VCVTDQ2PD (BX), X11             // c4617ae61b or c57ae61b
+       //TODO: VCVTDQ2PD (R11), X11            // c4417ae61b
+       //TODO: VCVTDQ2PD X2, X11               // c4617ae6da or c57ae6da
+       //TODO: VCVTDQ2PD X11, X11              // c4417ae6db
+       //TODO: VCVTDQ2PD (BX), Y2              // c4e17ee613 or c5fee613
+       //TODO: VCVTDQ2PD (R11), Y2             // c4c17ee613
+       //TODO: VCVTDQ2PD X2, Y2                // c4e17ee6d2 or c5fee6d2
+       //TODO: VCVTDQ2PD X11, Y2               // c4c17ee6d3
+       //TODO: VCVTDQ2PD (BX), Y11             // c4617ee61b or c57ee61b
+       //TODO: VCVTDQ2PD (R11), Y11            // c4417ee61b
+       //TODO: VCVTDQ2PD X2, Y11               // c4617ee6da or c57ee6da
+       //TODO: VCVTDQ2PD X11, Y11              // c4417ee6db
+       //TODO: VCVTDQ2PS (BX), X2              // c4e1785b13 or c5f85b13
+       //TODO: VCVTDQ2PS (R11), X2             // c4c1785b13
+       //TODO: VCVTDQ2PS X2, X2                // c4e1785bd2 or c5f85bd2
+       //TODO: VCVTDQ2PS X11, X2               // c4c1785bd3
+       //TODO: VCVTDQ2PS (BX), X11             // c461785b1b or c5785b1b
+       //TODO: VCVTDQ2PS (R11), X11            // c441785b1b
+       //TODO: VCVTDQ2PS X2, X11               // c461785bda or c5785bda
+       //TODO: VCVTDQ2PS X11, X11              // c441785bdb
+       //TODO: VCVTDQ2PS (BX), Y2              // c4e17c5b13 or c5fc5b13
+       //TODO: VCVTDQ2PS (R11), Y2             // c4c17c5b13
+       //TODO: VCVTDQ2PS Y2, Y2                // c4e17c5bd2 or c5fc5bd2
+       //TODO: VCVTDQ2PS Y11, Y2               // c4c17c5bd3
+       //TODO: VCVTDQ2PS (BX), Y11             // c4617c5b1b or c57c5b1b
+       //TODO: VCVTDQ2PS (R11), Y11            // c4417c5b1b
+       //TODO: VCVTDQ2PS Y2, Y11               // c4617c5bda or c57c5bda
+       //TODO: VCVTDQ2PS Y11, Y11              // c4417c5bdb
+       //TODO: VCVTPD2DQX (BX), X2             // c4e17be613 or c5fbe613
+       //TODO: VCVTPD2DQX (R11), X2            // c4c17be613
+       //TODO: VCVTPD2DQX X2, X2               // c4e17be6d2 or c5fbe6d2
+       //TODO: VCVTPD2DQX X11, X2              // c4c17be6d3
+       //TODO: VCVTPD2DQX (BX), X11            // c4617be61b or c57be61b
+       //TODO: VCVTPD2DQX (R11), X11           // c4417be61b
+       //TODO: VCVTPD2DQX X2, X11              // c4617be6da or c57be6da
+       //TODO: VCVTPD2DQX X11, X11             // c4417be6db
+       //TODO: VCVTPD2DQY (BX), X2             // c4e17fe613 or c5ffe613
+       //TODO: VCVTPD2DQY (R11), X2            // c4c17fe613
+       //TODO: VCVTPD2DQY Y2, X2               // c4e17fe6d2 or c5ffe6d2
+       //TODO: VCVTPD2DQY Y11, X2              // c4c17fe6d3
+       //TODO: VCVTPD2DQY (BX), X11            // c4617fe61b or c57fe61b
+       //TODO: VCVTPD2DQY (R11), X11           // c4417fe61b
+       //TODO: VCVTPD2DQY Y2, X11              // c4617fe6da or c57fe6da
+       //TODO: VCVTPD2DQY Y11, X11             // c4417fe6db
+       //TODO: VCVTPD2PSX (BX), X2             // c4e1795a13 or c5f95a13
+       //TODO: VCVTPD2PSX (R11), X2            // c4c1795a13
+       //TODO: VCVTPD2PSX X2, X2               // c4e1795ad2 or c5f95ad2
+       //TODO: VCVTPD2PSX X11, X2              // c4c1795ad3
+       //TODO: VCVTPD2PSX (BX), X11            // c461795a1b or c5795a1b
+       //TODO: VCVTPD2PSX (R11), X11           // c441795a1b
+       //TODO: VCVTPD2PSX X2, X11              // c461795ada or c5795ada
+       //TODO: VCVTPD2PSX X11, X11             // c441795adb
+       //TODO: VCVTPD2PSY (BX), X2             // c4e17d5a13 or c5fd5a13
+       //TODO: VCVTPD2PSY (R11), X2            // c4c17d5a13
+       //TODO: VCVTPD2PSY Y2, X2               // c4e17d5ad2 or c5fd5ad2
+       //TODO: VCVTPD2PSY Y11, X2              // c4c17d5ad3
+       //TODO: VCVTPD2PSY (BX), X11            // c4617d5a1b or c57d5a1b
+       //TODO: VCVTPD2PSY (R11), X11           // c4417d5a1b
+       //TODO: VCVTPD2PSY Y2, X11              // c4617d5ada or c57d5ada
+       //TODO: VCVTPD2PSY Y11, X11             // c4417d5adb
+       //TODO: VCVTPH2PS (BX), X2              // c4e2791313
+       //TODO: VCVTPH2PS (R11), X2             // c4c2791313
+       //TODO: VCVTPH2PS X2, X2                // c4e27913d2
+       //TODO: VCVTPH2PS X11, X2               // c4c27913d3
+       //TODO: VCVTPH2PS (BX), X11             // c46279131b
+       //TODO: VCVTPH2PS (R11), X11            // c44279131b
+       //TODO: VCVTPH2PS X2, X11               // c4627913da
+       //TODO: VCVTPH2PS X11, X11              // c4427913db
+       //TODO: VCVTPH2PS (BX), Y2              // c4e27d1313
+       //TODO: VCVTPH2PS (R11), Y2             // c4c27d1313
+       //TODO: VCVTPH2PS X2, Y2                // c4e27d13d2
+       //TODO: VCVTPH2PS X11, Y2               // c4c27d13d3
+       //TODO: VCVTPH2PS (BX), Y11             // c4627d131b
+       //TODO: VCVTPH2PS (R11), Y11            // c4427d131b
+       //TODO: VCVTPH2PS X2, Y11               // c4627d13da
+       //TODO: VCVTPH2PS X11, Y11              // c4427d13db
+       //TODO: VCVTPS2DQ (BX), X2              // c4e1795b13 or c5f95b13
+       //TODO: VCVTPS2DQ (R11), X2             // c4c1795b13
+       //TODO: VCVTPS2DQ X2, X2                // c4e1795bd2 or c5f95bd2
+       //TODO: VCVTPS2DQ X11, X2               // c4c1795bd3
+       //TODO: VCVTPS2DQ (BX), X11             // c461795b1b or c5795b1b
+       //TODO: VCVTPS2DQ (R11), X11            // c441795b1b
+       //TODO: VCVTPS2DQ X2, X11               // c461795bda or c5795bda
+       //TODO: VCVTPS2DQ X11, X11              // c441795bdb
+       //TODO: VCVTPS2DQ (BX), Y2              // c4e17d5b13 or c5fd5b13
+       //TODO: VCVTPS2DQ (R11), Y2             // c4c17d5b13
+       //TODO: VCVTPS2DQ Y2, Y2                // c4e17d5bd2 or c5fd5bd2
+       //TODO: VCVTPS2DQ Y11, Y2               // c4c17d5bd3
+       //TODO: VCVTPS2DQ (BX), Y11             // c4617d5b1b or c57d5b1b
+       //TODO: VCVTPS2DQ (R11), Y11            // c4417d5b1b
+       //TODO: VCVTPS2DQ Y2, Y11               // c4617d5bda or c57d5bda
+       //TODO: VCVTPS2DQ Y11, Y11              // c4417d5bdb
+       //TODO: VCVTPS2PD (BX), X2              // c4e1785a13 or c5f85a13
+       //TODO: VCVTPS2PD (R11), X2             // c4c1785a13
+       //TODO: VCVTPS2PD X2, X2                // c4e1785ad2 or c5f85ad2
+       //TODO: VCVTPS2PD X11, X2               // c4c1785ad3
+       //TODO: VCVTPS2PD (BX), X11             // c461785a1b or c5785a1b
+       //TODO: VCVTPS2PD (R11), X11            // c441785a1b
+       //TODO: VCVTPS2PD X2, X11               // c461785ada or c5785ada
+       //TODO: VCVTPS2PD X11, X11              // c441785adb
+       //TODO: VCVTPS2PD (BX), Y2              // c4e17c5a13 or c5fc5a13
+       //TODO: VCVTPS2PD (R11), Y2             // c4c17c5a13
+       //TODO: VCVTPS2PD X2, Y2                // c4e17c5ad2 or c5fc5ad2
+       //TODO: VCVTPS2PD X11, Y2               // c4c17c5ad3
+       //TODO: VCVTPS2PD (BX), Y11             // c4617c5a1b or c57c5a1b
+       //TODO: VCVTPS2PD (R11), Y11            // c4417c5a1b
+       //TODO: VCVTPS2PD X2, Y11               // c4617c5ada or c57c5ada
+       //TODO: VCVTPS2PD X11, Y11              // c4417c5adb
+       //TODO: VCVTPS2PH $7, Y2, (BX)          // c4e37d1d1307
+       //TODO: VCVTPS2PH $7, Y11, (BX)         // c4637d1d1b07
+       //TODO: VCVTPS2PH $7, Y2, (R11)         // c4c37d1d1307
+       //TODO: VCVTPS2PH $7, Y11, (R11)        // c4437d1d1b07
+       //TODO: VCVTPS2PH $7, Y2, X2            // c4e37d1dd207
+       //TODO: VCVTPS2PH $7, Y11, X2           // c4637d1dda07
+       //TODO: VCVTPS2PH $7, Y2, X11           // c4c37d1dd307
+       //TODO: VCVTPS2PH $7, Y11, X11          // c4437d1ddb07
+       //TODO: VCVTPS2PH $7, X2, (BX)          // c4e3791d1307
+       //TODO: VCVTPS2PH $7, X11, (BX)         // c463791d1b07
+       //TODO: VCVTPS2PH $7, X2, (R11)         // c4c3791d1307
+       //TODO: VCVTPS2PH $7, X11, (R11)        // c443791d1b07
+       //TODO: VCVTPS2PH $7, X2, X2            // c4e3791dd207
+       //TODO: VCVTPS2PH $7, X11, X2           // c463791dda07
+       //TODO: VCVTPS2PH $7, X2, X11           // c4c3791dd307
+       //TODO: VCVTPS2PH $7, X11, X11          // c443791ddb07
+       //TODO: VCVTSD2SI (BX), DX              // c4e17b2d13 or c5fb2d13
+       //TODO: VCVTSD2SI (R11), DX             // c4c17b2d13
+       //TODO: VCVTSD2SI X2, DX                // c4e17b2dd2 or c5fb2dd2
+       //TODO: VCVTSD2SI X11, DX               // c4c17b2dd3
+       //TODO: VCVTSD2SI (BX), R11             // c4617b2d1b or c57b2d1b
+       //TODO: VCVTSD2SI (R11), R11            // c4417b2d1b
+       //TODO: VCVTSD2SI X2, R11               // c4617b2dda or c57b2dda
+       //TODO: VCVTSD2SI X11, R11              // c4417b2ddb
+       //TODO: VCVTSD2SIQ (BX), DX             // c4e1fb2d13
+       //TODO: VCVTSD2SIQ (R11), DX            // c4c1fb2d13
+       //TODO: VCVTSD2SIQ X2, DX               // c4e1fb2dd2
+       //TODO: VCVTSD2SIQ X11, DX              // c4c1fb2dd3
+       //TODO: VCVTSD2SIQ (BX), R11            // c461fb2d1b
+       //TODO: VCVTSD2SIQ (R11), R11           // c441fb2d1b
+       //TODO: VCVTSD2SIQ X2, R11              // c461fb2dda
+       //TODO: VCVTSD2SIQ X11, R11             // c441fb2ddb
+       //TODO: VCVTSD2SS (BX), X9, X2          // c4e1335a13 or c5b35a13
+       //TODO: VCVTSD2SS (R11), X9, X2         // c4c1335a13
+       //TODO: VCVTSD2SS X2, X9, X2            // c4e1335ad2 or c5b35ad2
+       //TODO: VCVTSD2SS X11, X9, X2           // c4c1335ad3
+       //TODO: VCVTSD2SS (BX), X9, X11         // c461335a1b or c5335a1b
+       //TODO: VCVTSD2SS (R11), X9, X11        // c441335a1b
+       //TODO: VCVTSD2SS X2, X9, X11           // c461335ada or c5335ada
+       //TODO: VCVTSD2SS X11, X9, X11          // c441335adb
+       //TODO: VCVTSI2SDL (BX), X9, X2         // c4e1332a13 or c5b32a13
+       //TODO: VCVTSI2SDL (R11), X9, X2        // c4c1332a13
+       //TODO: VCVTSI2SDL DX, X9, X2           // c4e1332ad2 or c5b32ad2
+       //TODO: VCVTSI2SDL R11, X9, X2          // c4c1332ad3
+       //TODO: VCVTSI2SDL (BX), X9, X11        // c461332a1b or c5332a1b
+       //TODO: VCVTSI2SDL (R11), X9, X11       // c441332a1b
+       //TODO: VCVTSI2SDL DX, X9, X11          // c461332ada or c5332ada
+       //TODO: VCVTSI2SDL R11, X9, X11         // c441332adb
+       //TODO: VCVTSI2SDQ (BX), X9, X2         // c4e1b32a13
+       //TODO: VCVTSI2SDQ (R11), X9, X2        // c4c1b32a13
+       //TODO: VCVTSI2SDQ DX, X9, X2           // c4e1b32ad2
+       //TODO: VCVTSI2SDQ R11, X9, X2          // c4c1b32ad3
+       //TODO: VCVTSI2SDQ (BX), X9, X11        // c461b32a1b
+       //TODO: VCVTSI2SDQ (R11), X9, X11       // c441b32a1b
+       //TODO: VCVTSI2SDQ DX, X9, X11          // c461b32ada
+       //TODO: VCVTSI2SDQ R11, X9, X11         // c441b32adb
+       //TODO: VCVTSI2SSL (BX), X9, X2         // c4e1322a13 or c5b22a13
+       //TODO: VCVTSI2SSL (R11), X9, X2        // c4c1322a13
+       //TODO: VCVTSI2SSL DX, X9, X2           // c4e1322ad2 or c5b22ad2
+       //TODO: VCVTSI2SSL R11, X9, X2          // c4c1322ad3
+       //TODO: VCVTSI2SSL (BX), X9, X11        // c461322a1b or c5322a1b
+       //TODO: VCVTSI2SSL (R11), X9, X11       // c441322a1b
+       //TODO: VCVTSI2SSL DX, X9, X11          // c461322ada or c5322ada
+       //TODO: VCVTSI2SSL R11, X9, X11         // c441322adb
+       //TODO: VCVTSI2SSQ (BX), X9, X2         // c4e1b22a13
+       //TODO: VCVTSI2SSQ (R11), X9, X2        // c4c1b22a13
+       //TODO: VCVTSI2SSQ DX, X9, X2           // c4e1b22ad2
+       //TODO: VCVTSI2SSQ R11, X9, X2          // c4c1b22ad3
+       //TODO: VCVTSI2SSQ (BX), X9, X11        // c461b22a1b
+       //TODO: VCVTSI2SSQ (R11), X9, X11       // c441b22a1b
+       //TODO: VCVTSI2SSQ DX, X9, X11          // c461b22ada
+       //TODO: VCVTSI2SSQ R11, X9, X11         // c441b22adb
+       //TODO: VCVTSS2SD (BX), X9, X2          // c4e1325a13 or c5b25a13
+       //TODO: VCVTSS2SD (R11), X9, X2         // c4c1325a13
+       //TODO: VCVTSS2SD X2, X9, X2            // c4e1325ad2 or c5b25ad2
+       //TODO: VCVTSS2SD X11, X9, X2           // c4c1325ad3
+       //TODO: VCVTSS2SD (BX), X9, X11         // c461325a1b or c5325a1b
+       //TODO: VCVTSS2SD (R11), X9, X11        // c441325a1b
+       //TODO: VCVTSS2SD X2, X9, X11           // c461325ada or c5325ada
+       //TODO: VCVTSS2SD X11, X9, X11          // c441325adb
+       //TODO: VCVTSS2SI (BX), DX              // c4e17a2d13 or c5fa2d13
+       //TODO: VCVTSS2SI (R11), DX             // c4c17a2d13
+       //TODO: VCVTSS2SI X2, DX                // c4e17a2dd2 or c5fa2dd2
+       //TODO: VCVTSS2SI X11, DX               // c4c17a2dd3
+       //TODO: VCVTSS2SI (BX), R11             // c4617a2d1b or c57a2d1b
+       //TODO: VCVTSS2SI (R11), R11            // c4417a2d1b
+       //TODO: VCVTSS2SI X2, R11               // c4617a2dda or c57a2dda
+       //TODO: VCVTSS2SI X11, R11              // c4417a2ddb
+       //TODO: VCVTSS2SIQ (BX), DX             // c4e1fa2d13
+       //TODO: VCVTSS2SIQ (R11), DX            // c4c1fa2d13
+       //TODO: VCVTSS2SIQ X2, DX               // c4e1fa2dd2
+       //TODO: VCVTSS2SIQ X11, DX              // c4c1fa2dd3
+       //TODO: VCVTSS2SIQ (BX), R11            // c461fa2d1b
+       //TODO: VCVTSS2SIQ (R11), R11           // c441fa2d1b
+       //TODO: VCVTSS2SIQ X2, R11              // c461fa2dda
+       //TODO: VCVTSS2SIQ X11, R11             // c441fa2ddb
+       //TODO: VCVTTPD2DQX (BX), X2            // c4e179e613 or c5f9e613
+       //TODO: VCVTTPD2DQX (R11), X2           // c4c179e613
+       //TODO: VCVTTPD2DQX X2, X2              // c4e179e6d2 or c5f9e6d2
+       //TODO: VCVTTPD2DQX X11, X2             // c4c179e6d3
+       //TODO: VCVTTPD2DQX (BX), X11           // c46179e61b or c579e61b
+       //TODO: VCVTTPD2DQX (R11), X11          // c44179e61b
+       //TODO: VCVTTPD2DQX X2, X11             // c46179e6da or c579e6da
+       //TODO: VCVTTPD2DQX X11, X11            // c44179e6db
+       //TODO: VCVTTPD2DQY (BX), X2            // c4e17de613 or c5fde613
+       //TODO: VCVTTPD2DQY (R11), X2           // c4c17de613
+       //TODO: VCVTTPD2DQY Y2, X2              // c4e17de6d2 or c5fde6d2
+       //TODO: VCVTTPD2DQY Y11, X2             // c4c17de6d3
+       //TODO: VCVTTPD2DQY (BX), X11           // c4617de61b or c57de61b
+       //TODO: VCVTTPD2DQY (R11), X11          // c4417de61b
+       //TODO: VCVTTPD2DQY Y2, X11             // c4617de6da or c57de6da
+       //TODO: VCVTTPD2DQY Y11, X11            // c4417de6db
+       //TODO: VCVTTPS2DQ (BX), X2             // c4e17a5b13 or c5fa5b13
+       //TODO: VCVTTPS2DQ (R11), X2            // c4c17a5b13
+       //TODO: VCVTTPS2DQ X2, X2               // c4e17a5bd2 or c5fa5bd2
+       //TODO: VCVTTPS2DQ X11, X2              // c4c17a5bd3
+       //TODO: VCVTTPS2DQ (BX), X11            // c4617a5b1b or c57a5b1b
+       //TODO: VCVTTPS2DQ (R11), X11           // c4417a5b1b
+       //TODO: VCVTTPS2DQ X2, X11              // c4617a5bda or c57a5bda
+       //TODO: VCVTTPS2DQ X11, X11             // c4417a5bdb
+       //TODO: VCVTTPS2DQ (BX), Y2             // c4e17e5b13 or c5fe5b13
+       //TODO: VCVTTPS2DQ (R11), Y2            // c4c17e5b13
+       //TODO: VCVTTPS2DQ Y2, Y2               // c4e17e5bd2 or c5fe5bd2
+       //TODO: VCVTTPS2DQ Y11, Y2              // c4c17e5bd3
+       //TODO: VCVTTPS2DQ (BX), Y11            // c4617e5b1b or c57e5b1b
+       //TODO: VCVTTPS2DQ (R11), Y11           // c4417e5b1b
+       //TODO: VCVTTPS2DQ Y2, Y11              // c4617e5bda or c57e5bda
+       //TODO: VCVTTPS2DQ Y11, Y11             // c4417e5bdb
+       //TODO: VCVTTSD2SI (BX), DX             // c4e17b2c13 or c5fb2c13
+       //TODO: VCVTTSD2SI (R11), DX            // c4c17b2c13
+       //TODO: VCVTTSD2SI X2, DX               // c4e17b2cd2 or c5fb2cd2
+       //TODO: VCVTTSD2SI X11, DX              // c4c17b2cd3
+       //TODO: VCVTTSD2SI (BX), R11            // c4617b2c1b or c57b2c1b
+       //TODO: VCVTTSD2SI (R11), R11           // c4417b2c1b
+       //TODO: VCVTTSD2SI X2, R11              // c4617b2cda or c57b2cda
+       //TODO: VCVTTSD2SI X11, R11             // c4417b2cdb
+       //TODO: VCVTTSD2SIQ (BX), DX            // c4e1fb2c13
+       //TODO: VCVTTSD2SIQ (R11), DX           // c4c1fb2c13
+       //TODO: VCVTTSD2SIQ X2, DX              // c4e1fb2cd2
+       //TODO: VCVTTSD2SIQ X11, DX             // c4c1fb2cd3
+       //TODO: VCVTTSD2SIQ (BX), R11           // c461fb2c1b
+       //TODO: VCVTTSD2SIQ (R11), R11          // c441fb2c1b
+       //TODO: VCVTTSD2SIQ X2, R11             // c461fb2cda
+       //TODO: VCVTTSD2SIQ X11, R11            // c441fb2cdb
+       //TODO: VCVTTSS2SI (BX), DX             // c4e17a2c13 or c5fa2c13
+       //TODO: VCVTTSS2SI (R11), DX            // c4c17a2c13
+       //TODO: VCVTTSS2SI X2, DX               // c4e17a2cd2 or c5fa2cd2
+       //TODO: VCVTTSS2SI X11, DX              // c4c17a2cd3
+       //TODO: VCVTTSS2SI (BX), R11            // c4617a2c1b or c57a2c1b
+       //TODO: VCVTTSS2SI (R11), R11           // c4417a2c1b
+       //TODO: VCVTTSS2SI X2, R11              // c4617a2cda or c57a2cda
+       //TODO: VCVTTSS2SI X11, R11             // c4417a2cdb
+       //TODO: VCVTTSS2SIQ (BX), DX            // c4e1fa2c13
+       //TODO: VCVTTSS2SIQ (R11), DX           // c4c1fa2c13
+       //TODO: VCVTTSS2SIQ X2, DX              // c4e1fa2cd2
+       //TODO: VCVTTSS2SIQ X11, DX             // c4c1fa2cd3
+       //TODO: VCVTTSS2SIQ (BX), R11           // c461fa2c1b
+       //TODO: VCVTTSS2SIQ (R11), R11          // c441fa2c1b
+       //TODO: VCVTTSS2SIQ X2, R11             // c461fa2cda
+       //TODO: VCVTTSS2SIQ X11, R11            // c441fa2cdb
+       //TODO: VDIVPD (BX), X9, X2             // c4e1315e13 or c5b15e13
+       //TODO: VDIVPD (R11), X9, X2            // c4c1315e13
+       //TODO: VDIVPD X2, X9, X2               // c4e1315ed2 or c5b15ed2
+       //TODO: VDIVPD X11, X9, X2              // c4c1315ed3
+       //TODO: VDIVPD (BX), X9, X11            // c461315e1b or c5315e1b
+       //TODO: VDIVPD (R11), X9, X11           // c441315e1b
+       //TODO: VDIVPD X2, X9, X11              // c461315eda or c5315eda
+       //TODO: VDIVPD X11, X9, X11             // c441315edb
+       //TODO: VDIVPD (BX), Y15, Y2            // c4e1055e13 or c5855e13
+       //TODO: VDIVPD (R11), Y15, Y2           // c4c1055e13
+       //TODO: VDIVPD Y2, Y15, Y2              // c4e1055ed2 or c5855ed2
+       //TODO: VDIVPD Y11, Y15, Y2             // c4c1055ed3
+       //TODO: VDIVPD (BX), Y15, Y11           // c461055e1b or c5055e1b
+       //TODO: VDIVPD (R11), Y15, Y11          // c441055e1b
+       //TODO: VDIVPD Y2, Y15, Y11             // c461055eda or c5055eda
+       //TODO: VDIVPD Y11, Y15, Y11            // c441055edb
+       //TODO: VDIVPS (BX), X9, X2             // c4e1305e13 or c5b05e13
+       //TODO: VDIVPS (R11), X9, X2            // c4c1305e13
+       //TODO: VDIVPS X2, X9, X2               // c4e1305ed2 or c5b05ed2
+       //TODO: VDIVPS X11, X9, X2              // c4c1305ed3
+       //TODO: VDIVPS (BX), X9, X11            // c461305e1b or c5305e1b
+       //TODO: VDIVPS (R11), X9, X11           // c441305e1b
+       //TODO: VDIVPS X2, X9, X11              // c461305eda or c5305eda
+       //TODO: VDIVPS X11, X9, X11             // c441305edb
+       //TODO: VDIVPS (BX), Y15, Y2            // c4e1045e13 or c5845e13
+       //TODO: VDIVPS (R11), Y15, Y2           // c4c1045e13
+       //TODO: VDIVPS Y2, Y15, Y2              // c4e1045ed2 or c5845ed2
+       //TODO: VDIVPS Y11, Y15, Y2             // c4c1045ed3
+       //TODO: VDIVPS (BX), Y15, Y11           // c461045e1b or c5045e1b
+       //TODO: VDIVPS (R11), Y15, Y11          // c441045e1b
+       //TODO: VDIVPS Y2, Y15, Y11             // c461045eda or c5045eda
+       //TODO: VDIVPS Y11, Y15, Y11            // c441045edb
+       //TODO: VDIVSD (BX), X9, X2             // c4e1335e13 or c5b35e13
+       //TODO: VDIVSD (R11), X9, X2            // c4c1335e13
+       //TODO: VDIVSD X2, X9, X2               // c4e1335ed2 or c5b35ed2
+       //TODO: VDIVSD X11, X9, X2              // c4c1335ed3
+       //TODO: VDIVSD (BX), X9, X11            // c461335e1b or c5335e1b
+       //TODO: VDIVSD (R11), X9, X11           // c441335e1b
+       //TODO: VDIVSD X2, X9, X11              // c461335eda or c5335eda
+       //TODO: VDIVSD X11, X9, X11             // c441335edb
+       //TODO: VDIVSS (BX), X9, X2             // c4e1325e13 or c5b25e13
+       //TODO: VDIVSS (R11), X9, X2            // c4c1325e13
+       //TODO: VDIVSS X2, X9, X2               // c4e1325ed2 or c5b25ed2
+       //TODO: VDIVSS X11, X9, X2              // c4c1325ed3
+       //TODO: VDIVSS (BX), X9, X11            // c461325e1b or c5325e1b
+       //TODO: VDIVSS (R11), X9, X11           // c441325e1b
+       //TODO: VDIVSS X2, X9, X11              // c461325eda or c5325eda
+       //TODO: VDIVSS X11, X9, X11             // c441325edb
+       //TODO: VDPPD $7, (BX), X9, X2          // c4e331411307
+       //TODO: VDPPD $7, (R11), X9, X2         // c4c331411307
+       //TODO: VDPPD $7, X2, X9, X2            // c4e33141d207
+       //TODO: VDPPD $7, X11, X9, X2           // c4c33141d307
+       //TODO: VDPPD $7, (BX), X9, X11         // c46331411b07
+       //TODO: VDPPD $7, (R11), X9, X11        // c44331411b07
+       //TODO: VDPPD $7, X2, X9, X11           // c4633141da07
+       //TODO: VDPPD $7, X11, X9, X11          // c4433141db07
+       //TODO: VDPPS $7, (BX), X9, X2          // c4e331401307
+       //TODO: VDPPS $7, (R11), X9, X2         // c4c331401307
+       //TODO: VDPPS $7, X2, X9, X2            // c4e33140d207
+       //TODO: VDPPS $7, X11, X9, X2           // c4c33140d307
+       //TODO: VDPPS $7, (BX), X9, X11         // c46331401b07
+       //TODO: VDPPS $7, (R11), X9, X11        // c44331401b07
+       //TODO: VDPPS $7, X2, X9, X11           // c4633140da07
+       //TODO: VDPPS $7, X11, X9, X11          // c4433140db07
+       //TODO: VDPPS $7, (BX), Y15, Y2         // c4e305401307
+       //TODO: VDPPS $7, (R11), Y15, Y2        // c4c305401307
+       //TODO: VDPPS $7, Y2, Y15, Y2           // c4e30540d207
+       //TODO: VDPPS $7, Y11, Y15, Y2          // c4c30540d307
+       //TODO: VDPPS $7, (BX), Y15, Y11        // c46305401b07
+       //TODO: VDPPS $7, (R11), Y15, Y11       // c44305401b07
+       //TODO: VDPPS $7, Y2, Y15, Y11          // c4630540da07
+       //TODO: VDPPS $7, Y11, Y15, Y11         // c4430540db07
+       VERR (BX)                               // 0f0023
+       VERR (R11)                              // 410f0023
+       VERR DX                                 // 0f00e2
+       VERR R11                                // 410f00e3
+       VERW (BX)                               // 0f002b
+       VERW (R11)                              // 410f002b
+       VERW DX                                 // 0f00ea
+       VERW R11                                // 410f00eb
+       //TODO: VEXTRACTF128 $7, Y2, (BX)       // c4e37d191307
+       //TODO: VEXTRACTF128 $7, Y11, (BX)      // c4637d191b07
+       //TODO: VEXTRACTF128 $7, Y2, (R11)      // c4c37d191307
+       //TODO: VEXTRACTF128 $7, Y11, (R11)     // c4437d191b07
+       //TODO: VEXTRACTF128 $7, Y2, X2         // c4e37d19d207
+       //TODO: VEXTRACTF128 $7, Y11, X2        // c4637d19da07
+       //TODO: VEXTRACTF128 $7, Y2, X11        // c4c37d19d307
+       //TODO: VEXTRACTF128 $7, Y11, X11       // c4437d19db07
+       //TODO: VEXTRACTI128 $7, Y2, (BX)       // c4e37d391307
+       //TODO: VEXTRACTI128 $7, Y11, (BX)      // c4637d391b07
+       //TODO: VEXTRACTI128 $7, Y2, (R11)      // c4c37d391307
+       //TODO: VEXTRACTI128 $7, Y11, (R11)     // c4437d391b07
+       //TODO: VEXTRACTI128 $7, Y2, X2         // c4e37d39d207
+       //TODO: VEXTRACTI128 $7, Y11, X2        // c4637d39da07
+       //TODO: VEXTRACTI128 $7, Y2, X11        // c4c37d39d307
+       //TODO: VEXTRACTI128 $7, Y11, X11       // c4437d39db07
+       //TODO: VEXTRACTPS $7, X2, (BX)         // c4e379171307
+       //TODO: VEXTRACTPS $7, X11, (BX)        // c46379171b07
+       //TODO: VEXTRACTPS $7, X2, (R11)        // c4c379171307
+       //TODO: VEXTRACTPS $7, X11, (R11)       // c44379171b07
+       //TODO: VEXTRACTPS $7, X2, DX           // c4e37917d207
+       //TODO: VEXTRACTPS $7, X11, DX          // c4637917da07
+       //TODO: VEXTRACTPS $7, X2, R11          // c4c37917d307
+       //TODO: VEXTRACTPS $7, X11, R11         // c4437917db07
+       //TODO: VFMADD132PD (BX), X9, X2        // c4e2b19813
+       //TODO: VFMADD132PD (R11), X9, X2       // c4c2b19813
+       //TODO: VFMADD132PD X2, X9, X2          // c4e2b198d2
+       //TODO: VFMADD132PD X11, X9, X2         // c4c2b198d3
+       //TODO: VFMADD132PD (BX), X9, X11       // c462b1981b
+       //TODO: VFMADD132PD (R11), X9, X11      // c442b1981b
+       //TODO: VFMADD132PD X2, X9, X11         // c462b198da
+       //TODO: VFMADD132PD X11, X9, X11        // c442b198db
+       //TODO: VFMADD132PD (BX), Y15, Y2       // c4e2859813
+       //TODO: VFMADD132PD (R11), Y15, Y2      // c4c2859813
+       //TODO: VFMADD132PD Y2, Y15, Y2         // c4e28598d2
+       //TODO: VFMADD132PD Y11, Y15, Y2        // c4c28598d3
+       //TODO: VFMADD132PD (BX), Y15, Y11      // c46285981b
+       //TODO: VFMADD132PD (R11), Y15, Y11     // c44285981b
+       //TODO: VFMADD132PD Y2, Y15, Y11        // c4628598da
+       //TODO: VFMADD132PD Y11, Y15, Y11       // c4428598db
+       //TODO: VFMADD132PS (BX), X9, X2        // c4e2319813
+       //TODO: VFMADD132PS (R11), X9, X2       // c4c2319813
+       //TODO: VFMADD132PS X2, X9, X2          // c4e23198d2
+       //TODO: VFMADD132PS X11, X9, X2         // c4c23198d3
+       //TODO: VFMADD132PS (BX), X9, X11       // c46231981b
+       //TODO: VFMADD132PS (R11), X9, X11      // c44231981b
+       //TODO: VFMADD132PS X2, X9, X11         // c4623198da
+       //TODO: VFMADD132PS X11, X9, X11        // c4423198db
+       //TODO: VFMADD132PS (BX), Y15, Y2       // c4e2059813
+       //TODO: VFMADD132PS (R11), Y15, Y2      // c4c2059813
+       //TODO: VFMADD132PS Y2, Y15, Y2         // c4e20598d2
+       //TODO: VFMADD132PS Y11, Y15, Y2        // c4c20598d3
+       //TODO: VFMADD132PS (BX), Y15, Y11      // c46205981b
+       //TODO: VFMADD132PS (R11), Y15, Y11     // c44205981b
+       //TODO: VFMADD132PS Y2, Y15, Y11        // c4620598da
+       //TODO: VFMADD132PS Y11, Y15, Y11       // c4420598db
+       //TODO: VFMADD132SD (BX), X9, X2        // c4e2b19913
+       //TODO: VFMADD132SD (R11), X9, X2       // c4c2b19913
+       //TODO: VFMADD132SD X2, X9, X2          // c4e2b199d2
+       //TODO: VFMADD132SD X11, X9, X2         // c4c2b199d3
+       //TODO: VFMADD132SD (BX), X9, X11       // c462b1991b
+       //TODO: VFMADD132SD (R11), X9, X11      // c442b1991b
+       //TODO: VFMADD132SD X2, X9, X11         // c462b199da
+       //TODO: VFMADD132SD X11, X9, X11        // c442b199db
+       //TODO: VFMADD132SS (BX), X9, X2        // c4e2319913
+       //TODO: VFMADD132SS (R11), X9, X2       // c4c2319913
+       //TODO: VFMADD132SS X2, X9, X2          // c4e23199d2
+       //TODO: VFMADD132SS X11, X9, X2         // c4c23199d3
+       //TODO: VFMADD132SS (BX), X9, X11       // c46231991b
+       //TODO: VFMADD132SS (R11), X9, X11      // c44231991b
+       //TODO: VFMADD132SS X2, X9, X11         // c4623199da
+       //TODO: VFMADD132SS X11, X9, X11        // c4423199db
+       //TODO: VFMADD213PD (BX), X9, X2        // c4e2b1a813
+       //TODO: VFMADD213PD (R11), X9, X2       // c4c2b1a813
+       //TODO: VFMADD213PD X2, X9, X2          // c4e2b1a8d2
+       //TODO: VFMADD213PD X11, X9, X2         // c4c2b1a8d3
+       //TODO: VFMADD213PD (BX), X9, X11       // c462b1a81b
+       //TODO: VFMADD213PD (R11), X9, X11      // c442b1a81b
+       //TODO: VFMADD213PD X2, X9, X11         // c462b1a8da
+       //TODO: VFMADD213PD X11, X9, X11        // c442b1a8db
+       //TODO: VFMADD213PD (BX), Y15, Y2       // c4e285a813
+       //TODO: VFMADD213PD (R11), Y15, Y2      // c4c285a813
+       //TODO: VFMADD213PD Y2, Y15, Y2         // c4e285a8d2
+       //TODO: VFMADD213PD Y11, Y15, Y2        // c4c285a8d3
+       //TODO: VFMADD213PD (BX), Y15, Y11      // c46285a81b
+       //TODO: VFMADD213PD (R11), Y15, Y11     // c44285a81b
+       //TODO: VFMADD213PD Y2, Y15, Y11        // c46285a8da
+       //TODO: VFMADD213PD Y11, Y15, Y11       // c44285a8db
+       //TODO: VFMADD213PS (BX), X9, X2        // c4e231a813
+       //TODO: VFMADD213PS (R11), X9, X2       // c4c231a813
+       //TODO: VFMADD213PS X2, X9, X2          // c4e231a8d2
+       //TODO: VFMADD213PS X11, X9, X2         // c4c231a8d3
+       //TODO: VFMADD213PS (BX), X9, X11       // c46231a81b
+       //TODO: VFMADD213PS (R11), X9, X11      // c44231a81b
+       //TODO: VFMADD213PS X2, X9, X11         // c46231a8da
+       //TODO: VFMADD213PS X11, X9, X11        // c44231a8db
+       //TODO: VFMADD213PS (BX), Y15, Y2       // c4e205a813
+       //TODO: VFMADD213PS (R11), Y15, Y2      // c4c205a813
+       //TODO: VFMADD213PS Y2, Y15, Y2         // c4e205a8d2
+       //TODO: VFMADD213PS Y11, Y15, Y2        // c4c205a8d3
+       //TODO: VFMADD213PS (BX), Y15, Y11      // c46205a81b
+       //TODO: VFMADD213PS (R11), Y15, Y11     // c44205a81b
+       //TODO: VFMADD213PS Y2, Y15, Y11        // c46205a8da
+       //TODO: VFMADD213PS Y11, Y15, Y11       // c44205a8db
+       //TODO: VFMADD213SD (BX), X9, X2        // c4e2b1a913
+       //TODO: VFMADD213SD (R11), X9, X2       // c4c2b1a913
+       //TODO: VFMADD213SD X2, X9, X2          // c4e2b1a9d2
+       //TODO: VFMADD213SD X11, X9, X2         // c4c2b1a9d3
+       //TODO: VFMADD213SD (BX), X9, X11       // c462b1a91b
+       //TODO: VFMADD213SD (R11), X9, X11      // c442b1a91b
+       //TODO: VFMADD213SD X2, X9, X11         // c462b1a9da
+       //TODO: VFMADD213SD X11, X9, X11        // c442b1a9db
+       //TODO: VFMADD213SS (BX), X9, X2        // c4e231a913
+       //TODO: VFMADD213SS (R11), X9, X2       // c4c231a913
+       //TODO: VFMADD213SS X2, X9, X2          // c4e231a9d2
+       //TODO: VFMADD213SS X11, X9, X2         // c4c231a9d3
+       //TODO: VFMADD213SS (BX), X9, X11       // c46231a91b
+       //TODO: VFMADD213SS (R11), X9, X11      // c44231a91b
+       //TODO: VFMADD213SS X2, X9, X11         // c46231a9da
+       //TODO: VFMADD213SS X11, X9, X11        // c44231a9db
+       //TODO: VFMADD231PD (BX), X9, X2        // c4e2b1b813
+       //TODO: VFMADD231PD (R11), X9, X2       // c4c2b1b813
+       //TODO: VFMADD231PD X2, X9, X2          // c4e2b1b8d2
+       //TODO: VFMADD231PD X11, X9, X2         // c4c2b1b8d3
+       //TODO: VFMADD231PD (BX), X9, X11       // c462b1b81b
+       //TODO: VFMADD231PD (R11), X9, X11      // c442b1b81b
+       //TODO: VFMADD231PD X2, X9, X11         // c462b1b8da
+       //TODO: VFMADD231PD X11, X9, X11        // c442b1b8db
+       //TODO: VFMADD231PD (BX), Y15, Y2       // c4e285b813
+       //TODO: VFMADD231PD (R11), Y15, Y2      // c4c285b813
+       //TODO: VFMADD231PD Y2, Y15, Y2         // c4e285b8d2
+       //TODO: VFMADD231PD Y11, Y15, Y2        // c4c285b8d3
+       //TODO: VFMADD231PD (BX), Y15, Y11      // c46285b81b
+       //TODO: VFMADD231PD (R11), Y15, Y11     // c44285b81b
+       //TODO: VFMADD231PD Y2, Y15, Y11        // c46285b8da
+       //TODO: VFMADD231PD Y11, Y15, Y11       // c44285b8db
+       //TODO: VFMADD231PS (BX), X9, X2        // c4e231b813
+       //TODO: VFMADD231PS (R11), X9, X2       // c4c231b813
+       //TODO: VFMADD231PS X2, X9, X2          // c4e231b8d2
+       //TODO: VFMADD231PS X11, X9, X2         // c4c231b8d3
+       //TODO: VFMADD231PS (BX), X9, X11       // c46231b81b
+       //TODO: VFMADD231PS (R11), X9, X11      // c44231b81b
+       //TODO: VFMADD231PS X2, X9, X11         // c46231b8da
+       //TODO: VFMADD231PS X11, X9, X11        // c44231b8db
+       //TODO: VFMADD231PS (BX), Y15, Y2       // c4e205b813
+       //TODO: VFMADD231PS (R11), Y15, Y2      // c4c205b813
+       //TODO: VFMADD231PS Y2, Y15, Y2         // c4e205b8d2
+       //TODO: VFMADD231PS Y11, Y15, Y2        // c4c205b8d3
+       //TODO: VFMADD231PS (BX), Y15, Y11      // c46205b81b
+       //TODO: VFMADD231PS (R11), Y15, Y11     // c44205b81b
+       //TODO: VFMADD231PS Y2, Y15, Y11        // c46205b8da
+       //TODO: VFMADD231PS Y11, Y15, Y11       // c44205b8db
+       //TODO: VFMADD231SD (BX), X9, X2        // c4e2b1b913
+       //TODO: VFMADD231SD (R11), X9, X2       // c4c2b1b913
+       //TODO: VFMADD231SD X2, X9, X2          // c4e2b1b9d2
+       //TODO: VFMADD231SD X11, X9, X2         // c4c2b1b9d3
+       //TODO: VFMADD231SD (BX), X9, X11       // c462b1b91b
+       //TODO: VFMADD231SD (R11), X9, X11      // c442b1b91b
+       //TODO: VFMADD231SD X2, X9, X11         // c462b1b9da
+       //TODO: VFMADD231SD X11, X9, X11        // c442b1b9db
+       //TODO: VFMADD231SS (BX), X9, X2        // c4e231b913
+       //TODO: VFMADD231SS (R11), X9, X2       // c4c231b913
+       //TODO: VFMADD231SS X2, X9, X2          // c4e231b9d2
+       //TODO: VFMADD231SS X11, X9, X2         // c4c231b9d3
+       //TODO: VFMADD231SS (BX), X9, X11       // c46231b91b
+       //TODO: VFMADD231SS (R11), X9, X11      // c44231b91b
+       //TODO: VFMADD231SS X2, X9, X11         // c46231b9da
+       //TODO: VFMADD231SS X11, X9, X11        // c44231b9db
+       //TODO: VFMADDSUB132PD (BX), X9, X2     // c4e2b19613
+       //TODO: VFMADDSUB132PD (R11), X9, X2    // c4c2b19613
+       //TODO: VFMADDSUB132PD X2, X9, X2       // c4e2b196d2
+       //TODO: VFMADDSUB132PD X11, X9, X2      // c4c2b196d3
+       //TODO: VFMADDSUB132PD (BX), X9, X11    // c462b1961b
+       //TODO: VFMADDSUB132PD (R11), X9, X11   // c442b1961b
+       //TODO: VFMADDSUB132PD X2, X9, X11      // c462b196da
+       //TODO: VFMADDSUB132PD X11, X9, X11     // c442b196db
+       //TODO: VFMADDSUB132PD (BX), Y15, Y2    // c4e2859613
+       //TODO: VFMADDSUB132PD (R11), Y15, Y2   // c4c2859613
+       //TODO: VFMADDSUB132PD Y2, Y15, Y2      // c4e28596d2
+       //TODO: VFMADDSUB132PD Y11, Y15, Y2     // c4c28596d3
+       //TODO: VFMADDSUB132PD (BX), Y15, Y11   // c46285961b
+       //TODO: VFMADDSUB132PD (R11), Y15, Y11  // c44285961b
+       //TODO: VFMADDSUB132PD Y2, Y15, Y11     // c4628596da
+       //TODO: VFMADDSUB132PD Y11, Y15, Y11    // c4428596db
+       //TODO: VFMADDSUB132PS (BX), X9, X2     // c4e2319613
+       //TODO: VFMADDSUB132PS (R11), X9, X2    // c4c2319613
+       //TODO: VFMADDSUB132PS X2, X9, X2       // c4e23196d2
+       //TODO: VFMADDSUB132PS X11, X9, X2      // c4c23196d3
+       //TODO: VFMADDSUB132PS (BX), X9, X11    // c46231961b
+       //TODO: VFMADDSUB132PS (R11), X9, X11   // c44231961b
+       //TODO: VFMADDSUB132PS X2, X9, X11      // c4623196da
+       //TODO: VFMADDSUB132PS X11, X9, X11     // c4423196db
+       //TODO: VFMADDSUB132PS (BX), Y15, Y2    // c4e2059613
+       //TODO: VFMADDSUB132PS (R11), Y15, Y2   // c4c2059613
+       //TODO: VFMADDSUB132PS Y2, Y15, Y2      // c4e20596d2
+       //TODO: VFMADDSUB132PS Y11, Y15, Y2     // c4c20596d3
+       //TODO: VFMADDSUB132PS (BX), Y15, Y11   // c46205961b
+       //TODO: VFMADDSUB132PS (R11), Y15, Y11  // c44205961b
+       //TODO: VFMADDSUB132PS Y2, Y15, Y11     // c4620596da
+       //TODO: VFMADDSUB132PS Y11, Y15, Y11    // c4420596db
+       //TODO: VFMADDSUB213PD (BX), X9, X2     // c4e2b1a613
+       //TODO: VFMADDSUB213PD (R11), X9, X2    // c4c2b1a613
+       //TODO: VFMADDSUB213PD X2, X9, X2       // c4e2b1a6d2
+       //TODO: VFMADDSUB213PD X11, X9, X2      // c4c2b1a6d3
+       //TODO: VFMADDSUB213PD (BX), X9, X11    // c462b1a61b
+       //TODO: VFMADDSUB213PD (R11), X9, X11   // c442b1a61b
+       //TODO: VFMADDSUB213PD X2, X9, X11      // c462b1a6da
+       //TODO: VFMADDSUB213PD X11, X9, X11     // c442b1a6db
+       //TODO: VFMADDSUB213PD (BX), Y15, Y2    // c4e285a613
+       //TODO: VFMADDSUB213PD (R11), Y15, Y2   // c4c285a613
+       //TODO: VFMADDSUB213PD Y2, Y15, Y2      // c4e285a6d2
+       //TODO: VFMADDSUB213PD Y11, Y15, Y2     // c4c285a6d3
+       //TODO: VFMADDSUB213PD (BX), Y15, Y11   // c46285a61b
+       //TODO: VFMADDSUB213PD (R11), Y15, Y11  // c44285a61b
+       //TODO: VFMADDSUB213PD Y2, Y15, Y11     // c46285a6da
+       //TODO: VFMADDSUB213PD Y11, Y15, Y11    // c44285a6db
+       //TODO: VFMADDSUB213PS (BX), X9, X2     // c4e231a613
+       //TODO: VFMADDSUB213PS (R11), X9, X2    // c4c231a613
+       //TODO: VFMADDSUB213PS X2, X9, X2       // c4e231a6d2
+       //TODO: VFMADDSUB213PS X11, X9, X2      // c4c231a6d3
+       //TODO: VFMADDSUB213PS (BX), X9, X11    // c46231a61b
+       //TODO: VFMADDSUB213PS (R11), X9, X11   // c44231a61b
+       //TODO: VFMADDSUB213PS X2, X9, X11      // c46231a6da
+       //TODO: VFMADDSUB213PS X11, X9, X11     // c44231a6db
+       //TODO: VFMADDSUB213PS (BX), Y15, Y2    // c4e205a613
+       //TODO: VFMADDSUB213PS (R11), Y15, Y2   // c4c205a613
+       //TODO: VFMADDSUB213PS Y2, Y15, Y2      // c4e205a6d2
+       //TODO: VFMADDSUB213PS Y11, Y15, Y2     // c4c205a6d3
+       //TODO: VFMADDSUB213PS (BX), Y15, Y11   // c46205a61b
+       //TODO: VFMADDSUB213PS (R11), Y15, Y11  // c44205a61b
+       //TODO: VFMADDSUB213PS Y2, Y15, Y11     // c46205a6da
+       //TODO: VFMADDSUB213PS Y11, Y15, Y11    // c44205a6db
+       //TODO: VFMADDSUB231PD (BX), X9, X2     // c4e2b1b613
+       //TODO: VFMADDSUB231PD (R11), X9, X2    // c4c2b1b613
+       //TODO: VFMADDSUB231PD X2, X9, X2       // c4e2b1b6d2
+       //TODO: VFMADDSUB231PD X11, X9, X2      // c4c2b1b6d3
+       //TODO: VFMADDSUB231PD (BX), X9, X11    // c462b1b61b
+       //TODO: VFMADDSUB231PD (R11), X9, X11   // c442b1b61b
+       //TODO: VFMADDSUB231PD X2, X9, X11      // c462b1b6da
+       //TODO: VFMADDSUB231PD X11, X9, X11     // c442b1b6db
+       //TODO: VFMADDSUB231PD (BX), Y15, Y2    // c4e285b613
+       //TODO: VFMADDSUB231PD (R11), Y15, Y2   // c4c285b613
+       //TODO: VFMADDSUB231PD Y2, Y15, Y2      // c4e285b6d2
+       //TODO: VFMADDSUB231PD Y11, Y15, Y2     // c4c285b6d3
+       //TODO: VFMADDSUB231PD (BX), Y15, Y11   // c46285b61b
+       //TODO: VFMADDSUB231PD (R11), Y15, Y11  // c44285b61b
+       //TODO: VFMADDSUB231PD Y2, Y15, Y11     // c46285b6da
+       //TODO: VFMADDSUB231PD Y11, Y15, Y11    // c44285b6db
+       //TODO: VFMADDSUB231PS (BX), X9, X2     // c4e231b613
+       //TODO: VFMADDSUB231PS (R11), X9, X2    // c4c231b613
+       //TODO: VFMADDSUB231PS X2, X9, X2       // c4e231b6d2
+       //TODO: VFMADDSUB231PS X11, X9, X2      // c4c231b6d3
+       //TODO: VFMADDSUB231PS (BX), X9, X11    // c46231b61b
+       //TODO: VFMADDSUB231PS (R11), X9, X11   // c44231b61b
+       //TODO: VFMADDSUB231PS X2, X9, X11      // c46231b6da
+       //TODO: VFMADDSUB231PS X11, X9, X11     // c44231b6db
+       //TODO: VFMADDSUB231PS (BX), Y15, Y2    // c4e205b613
+       //TODO: VFMADDSUB231PS (R11), Y15, Y2   // c4c205b613
+       //TODO: VFMADDSUB231PS Y2, Y15, Y2      // c4e205b6d2
+       //TODO: VFMADDSUB231PS Y11, Y15, Y2     // c4c205b6d3
+       //TODO: VFMADDSUB231PS (BX), Y15, Y11   // c46205b61b
+       //TODO: VFMADDSUB231PS (R11), Y15, Y11  // c44205b61b
+       //TODO: VFMADDSUB231PS Y2, Y15, Y11     // c46205b6da
+       //TODO: VFMADDSUB231PS Y11, Y15, Y11    // c44205b6db
+       //TODO: VFMSUB132PD (BX), X9, X2        // c4e2b19a13
+       //TODO: VFMSUB132PD (R11), X9, X2       // c4c2b19a13
+       //TODO: VFMSUB132PD X2, X9, X2          // c4e2b19ad2
+       //TODO: VFMSUB132PD X11, X9, X2         // c4c2b19ad3
+       //TODO: VFMSUB132PD (BX), X9, X11       // c462b19a1b
+       //TODO: VFMSUB132PD (R11), X9, X11      // c442b19a1b
+       //TODO: VFMSUB132PD X2, X9, X11         // c462b19ada
+       //TODO: VFMSUB132PD X11, X9, X11        // c442b19adb
+       //TODO: VFMSUB132PD (BX), Y15, Y2       // c4e2859a13
+       //TODO: VFMSUB132PD (R11), Y15, Y2      // c4c2859a13
+       //TODO: VFMSUB132PD Y2, Y15, Y2         // c4e2859ad2
+       //TODO: VFMSUB132PD Y11, Y15, Y2        // c4c2859ad3
+       //TODO: VFMSUB132PD (BX), Y15, Y11      // c462859a1b
+       //TODO: VFMSUB132PD (R11), Y15, Y11     // c442859a1b
+       //TODO: VFMSUB132PD Y2, Y15, Y11        // c462859ada
+       //TODO: VFMSUB132PD Y11, Y15, Y11       // c442859adb
+       //TODO: VFMSUB132PS (BX), X9, X2        // c4e2319a13
+       //TODO: VFMSUB132PS (R11), X9, X2       // c4c2319a13
+       //TODO: VFMSUB132PS X2, X9, X2          // c4e2319ad2
+       //TODO: VFMSUB132PS X11, X9, X2         // c4c2319ad3
+       //TODO: VFMSUB132PS (BX), X9, X11       // c462319a1b
+       //TODO: VFMSUB132PS (R11), X9, X11      // c442319a1b
+       //TODO: VFMSUB132PS X2, X9, X11         // c462319ada
+       //TODO: VFMSUB132PS X11, X9, X11        // c442319adb
+       //TODO: VFMSUB132PS (BX), Y15, Y2       // c4e2059a13
+       //TODO: VFMSUB132PS (R11), Y15, Y2      // c4c2059a13
+       //TODO: VFMSUB132PS Y2, Y15, Y2         // c4e2059ad2
+       //TODO: VFMSUB132PS Y11, Y15, Y2        // c4c2059ad3
+       //TODO: VFMSUB132PS (BX), Y15, Y11      // c462059a1b
+       //TODO: VFMSUB132PS (R11), Y15, Y11     // c442059a1b
+       //TODO: VFMSUB132PS Y2, Y15, Y11        // c462059ada
+       //TODO: VFMSUB132PS Y11, Y15, Y11       // c442059adb
+       //TODO: VFMSUB132SD (BX), X9, X2        // c4e2b19b13
+       //TODO: VFMSUB132SD (R11), X9, X2       // c4c2b19b13
+       //TODO: VFMSUB132SD X2, X9, X2          // c4e2b19bd2
+       //TODO: VFMSUB132SD X11, X9, X2         // c4c2b19bd3
+       //TODO: VFMSUB132SD (BX), X9, X11       // c462b19b1b
+       //TODO: VFMSUB132SD (R11), X9, X11      // c442b19b1b
+       //TODO: VFMSUB132SD X2, X9, X11         // c462b19bda
+       //TODO: VFMSUB132SD X11, X9, X11        // c442b19bdb
+       //TODO: VFMSUB132SS (BX), X9, X2        // c4e2319b13
+       //TODO: VFMSUB132SS (R11), X9, X2       // c4c2319b13
+       //TODO: VFMSUB132SS X2, X9, X2          // c4e2319bd2
+       //TODO: VFMSUB132SS X11, X9, X2         // c4c2319bd3
+       //TODO: VFMSUB132SS (BX), X9, X11       // c462319b1b
+       //TODO: VFMSUB132SS (R11), X9, X11      // c442319b1b
+       //TODO: VFMSUB132SS X2, X9, X11         // c462319bda
+       //TODO: VFMSUB132SS X11, X9, X11        // c442319bdb
+       //TODO: VFMSUB213PD (BX), X9, X2        // c4e2b1aa13
+       //TODO: VFMSUB213PD (R11), X9, X2       // c4c2b1aa13
+       //TODO: VFMSUB213PD X2, X9, X2          // c4e2b1aad2
+       //TODO: VFMSUB213PD X11, X9, X2         // c4c2b1aad3
+       //TODO: VFMSUB213PD (BX), X9, X11       // c462b1aa1b
+       //TODO: VFMSUB213PD (R11), X9, X11      // c442b1aa1b
+       //TODO: VFMSUB213PD X2, X9, X11         // c462b1aada
+       //TODO: VFMSUB213PD X11, X9, X11        // c442b1aadb
+       //TODO: VFMSUB213PD (BX), Y15, Y2       // c4e285aa13
+       //TODO: VFMSUB213PD (R11), Y15, Y2      // c4c285aa13
+       //TODO: VFMSUB213PD Y2, Y15, Y2         // c4e285aad2
+       //TODO: VFMSUB213PD Y11, Y15, Y2        // c4c285aad3
+       //TODO: VFMSUB213PD (BX), Y15, Y11      // c46285aa1b
+       //TODO: VFMSUB213PD (R11), Y15, Y11     // c44285aa1b
+       //TODO: VFMSUB213PD Y2, Y15, Y11        // c46285aada
+       //TODO: VFMSUB213PD Y11, Y15, Y11       // c44285aadb
+       //TODO: VFMSUB213PS (BX), X9, X2        // c4e231aa13
+       //TODO: VFMSUB213PS (R11), X9, X2       // c4c231aa13
+       //TODO: VFMSUB213PS X2, X9, X2          // c4e231aad2
+       //TODO: VFMSUB213PS X11, X9, X2         // c4c231aad3
+       //TODO: VFMSUB213PS (BX), X9, X11       // c46231aa1b
+       //TODO: VFMSUB213PS (R11), X9, X11      // c44231aa1b
+       //TODO: VFMSUB213PS X2, X9, X11         // c46231aada
+       //TODO: VFMSUB213PS X11, X9, X11        // c44231aadb
+       //TODO: VFMSUB213PS (BX), Y15, Y2       // c4e205aa13
+       //TODO: VFMSUB213PS (R11), Y15, Y2      // c4c205aa13
+       //TODO: VFMSUB213PS Y2, Y15, Y2         // c4e205aad2
+       //TODO: VFMSUB213PS Y11, Y15, Y2        // c4c205aad3
+       //TODO: VFMSUB213PS (BX), Y15, Y11      // c46205aa1b
+       //TODO: VFMSUB213PS (R11), Y15, Y11     // c44205aa1b
+       //TODO: VFMSUB213PS Y2, Y15, Y11        // c46205aada
+       //TODO: VFMSUB213PS Y11, Y15, Y11       // c44205aadb
+       //TODO: VFMSUB213SD (BX), X9, X2        // c4e2b1ab13
+       //TODO: VFMSUB213SD (R11), X9, X2       // c4c2b1ab13
+       //TODO: VFMSUB213SD X2, X9, X2          // c4e2b1abd2
+       //TODO: VFMSUB213SD X11, X9, X2         // c4c2b1abd3
+       //TODO: VFMSUB213SD (BX), X9, X11       // c462b1ab1b
+       //TODO: VFMSUB213SD (R11), X9, X11      // c442b1ab1b
+       //TODO: VFMSUB213SD X2, X9, X11         // c462b1abda
+       //TODO: VFMSUB213SD X11, X9, X11        // c442b1abdb
+       //TODO: VFMSUB213SS (BX), X9, X2        // c4e231ab13
+       //TODO: VFMSUB213SS (R11), X9, X2       // c4c231ab13
+       //TODO: VFMSUB213SS X2, X9, X2          // c4e231abd2
+       //TODO: VFMSUB213SS X11, X9, X2         // c4c231abd3
+       //TODO: VFMSUB213SS (BX), X9, X11       // c46231ab1b
+       //TODO: VFMSUB213SS (R11), X9, X11      // c44231ab1b
+       //TODO: VFMSUB213SS X2, X9, X11         // c46231abda
+       //TODO: VFMSUB213SS X11, X9, X11        // c44231abdb
+       //TODO: VFMSUB231PD (BX), X9, X2        // c4e2b1ba13
+       //TODO: VFMSUB231PD (R11), X9, X2       // c4c2b1ba13
+       //TODO: VFMSUB231PD X2, X9, X2          // c4e2b1bad2
+       //TODO: VFMSUB231PD X11, X9, X2         // c4c2b1bad3
+       //TODO: VFMSUB231PD (BX), X9, X11       // c462b1ba1b
+       //TODO: VFMSUB231PD (R11), X9, X11      // c442b1ba1b
+       //TODO: VFMSUB231PD X2, X9, X11         // c462b1bada
+       //TODO: VFMSUB231PD X11, X9, X11        // c442b1badb
+       //TODO: VFMSUB231PD (BX), Y15, Y2       // c4e285ba13
+       //TODO: VFMSUB231PD (R11), Y15, Y2      // c4c285ba13
+       //TODO: VFMSUB231PD Y2, Y15, Y2         // c4e285bad2
+       //TODO: VFMSUB231PD Y11, Y15, Y2        // c4c285bad3
+       //TODO: VFMSUB231PD (BX), Y15, Y11      // c46285ba1b
+       //TODO: VFMSUB231PD (R11), Y15, Y11     // c44285ba1b
+       //TODO: VFMSUB231PD Y2, Y15, Y11        // c46285bada
+       //TODO: VFMSUB231PD Y11, Y15, Y11       // c44285badb
+       //TODO: VFMSUB231PS (BX), X9, X2        // c4e231ba13
+       //TODO: VFMSUB231PS (R11), X9, X2       // c4c231ba13
+       //TODO: VFMSUB231PS X2, X9, X2          // c4e231bad2
+       //TODO: VFMSUB231PS X11, X9, X2         // c4c231bad3
+       //TODO: VFMSUB231PS (BX), X9, X11       // c46231ba1b
+       //TODO: VFMSUB231PS (R11), X9, X11      // c44231ba1b
+       //TODO: VFMSUB231PS X2, X9, X11         // c46231bada
+       //TODO: VFMSUB231PS X11, X9, X11        // c44231badb
+       //TODO: VFMSUB231PS (BX), Y15, Y2       // c4e205ba13
+       //TODO: VFMSUB231PS (R11), Y15, Y2      // c4c205ba13
+       //TODO: VFMSUB231PS Y2, Y15, Y2         // c4e205bad2
+       //TODO: VFMSUB231PS Y11, Y15, Y2        // c4c205bad3
+       //TODO: VFMSUB231PS (BX), Y15, Y11      // c46205ba1b
+       //TODO: VFMSUB231PS (R11), Y15, Y11     // c44205ba1b
+       //TODO: VFMSUB231PS Y2, Y15, Y11        // c46205bada
+       //TODO: VFMSUB231PS Y11, Y15, Y11       // c44205badb
+       //TODO: VFMSUB231SD (BX), X9, X2        // c4e2b1bb13
+       //TODO: VFMSUB231SD (R11), X9, X2       // c4c2b1bb13
+       //TODO: VFMSUB231SD X2, X9, X2          // c4e2b1bbd2
+       //TODO: VFMSUB231SD X11, X9, X2         // c4c2b1bbd3
+       //TODO: VFMSUB231SD (BX), X9, X11       // c462b1bb1b
+       //TODO: VFMSUB231SD (R11), X9, X11      // c442b1bb1b
+       //TODO: VFMSUB231SD X2, X9, X11         // c462b1bbda
+       //TODO: VFMSUB231SD X11, X9, X11        // c442b1bbdb
+       //TODO: VFMSUB231SS (BX), X9, X2        // c4e231bb13
+       //TODO: VFMSUB231SS (R11), X9, X2       // c4c231bb13
+       //TODO: VFMSUB231SS X2, X9, X2          // c4e231bbd2
+       //TODO: VFMSUB231SS X11, X9, X2         // c4c231bbd3
+       //TODO: VFMSUB231SS (BX), X9, X11       // c46231bb1b
+       //TODO: VFMSUB231SS (R11), X9, X11      // c44231bb1b
+       //TODO: VFMSUB231SS X2, X9, X11         // c46231bbda
+       //TODO: VFMSUB231SS X11, X9, X11        // c44231bbdb
+       //TODO: VFMSUBADD132PD (BX), X9, X2     // c4e2b19713
+       //TODO: VFMSUBADD132PD (R11), X9, X2    // c4c2b19713
+       //TODO: VFMSUBADD132PD X2, X9, X2       // c4e2b197d2
+       //TODO: VFMSUBADD132PD X11, X9, X2      // c4c2b197d3
+       //TODO: VFMSUBADD132PD (BX), X9, X11    // c462b1971b
+       //TODO: VFMSUBADD132PD (R11), X9, X11   // c442b1971b
+       //TODO: VFMSUBADD132PD X2, X9, X11      // c462b197da
+       //TODO: VFMSUBADD132PD X11, X9, X11     // c442b197db
+       //TODO: VFMSUBADD132PD (BX), Y15, Y2    // c4e2859713
+       //TODO: VFMSUBADD132PD (R11), Y15, Y2   // c4c2859713
+       //TODO: VFMSUBADD132PD Y2, Y15, Y2      // c4e28597d2
+       //TODO: VFMSUBADD132PD Y11, Y15, Y2     // c4c28597d3
+       //TODO: VFMSUBADD132PD (BX), Y15, Y11   // c46285971b
+       //TODO: VFMSUBADD132PD (R11), Y15, Y11  // c44285971b
+       //TODO: VFMSUBADD132PD Y2, Y15, Y11     // c4628597da
+       //TODO: VFMSUBADD132PD Y11, Y15, Y11    // c4428597db
+       //TODO: VFMSUBADD132PS (BX), X9, X2     // c4e2319713
+       //TODO: VFMSUBADD132PS (R11), X9, X2    // c4c2319713
+       //TODO: VFMSUBADD132PS X2, X9, X2       // c4e23197d2
+       //TODO: VFMSUBADD132PS X11, X9, X2      // c4c23197d3
+       //TODO: VFMSUBADD132PS (BX), X9, X11    // c46231971b
+       //TODO: VFMSUBADD132PS (R11), X9, X11   // c44231971b
+       //TODO: VFMSUBADD132PS X2, X9, X11      // c4623197da
+       //TODO: VFMSUBADD132PS X11, X9, X11     // c4423197db
+       //TODO: VFMSUBADD132PS (BX), Y15, Y2    // c4e2059713
+       //TODO: VFMSUBADD132PS (R11), Y15, Y2   // c4c2059713
+       //TODO: VFMSUBADD132PS Y2, Y15, Y2      // c4e20597d2
+       //TODO: VFMSUBADD132PS Y11, Y15, Y2     // c4c20597d3
+       //TODO: VFMSUBADD132PS (BX), Y15, Y11   // c46205971b
+       //TODO: VFMSUBADD132PS (R11), Y15, Y11  // c44205971b
+       //TODO: VFMSUBADD132PS Y2, Y15, Y11     // c4620597da
+       //TODO: VFMSUBADD132PS Y11, Y15, Y11    // c4420597db
+       //TODO: VFMSUBADD213PD (BX), X9, X2     // c4e2b1a713
+       //TODO: VFMSUBADD213PD (R11), X9, X2    // c4c2b1a713
+       //TODO: VFMSUBADD213PD X2, X9, X2       // c4e2b1a7d2
+       //TODO: VFMSUBADD213PD X11, X9, X2      // c4c2b1a7d3
+       //TODO: VFMSUBADD213PD (BX), X9, X11    // c462b1a71b
+       //TODO: VFMSUBADD213PD (R11), X9, X11   // c442b1a71b
+       //TODO: VFMSUBADD213PD X2, X9, X11      // c462b1a7da
+       //TODO: VFMSUBADD213PD X11, X9, X11     // c442b1a7db
+       //TODO: VFMSUBADD213PD (BX), Y15, Y2    // c4e285a713
+       //TODO: VFMSUBADD213PD (R11), Y15, Y2   // c4c285a713
+       //TODO: VFMSUBADD213PD Y2, Y15, Y2      // c4e285a7d2
+       //TODO: VFMSUBADD213PD Y11, Y15, Y2     // c4c285a7d3
+       //TODO: VFMSUBADD213PD (BX), Y15, Y11   // c46285a71b
+       //TODO: VFMSUBADD213PD (R11), Y15, Y11  // c44285a71b
+       //TODO: VFMSUBADD213PD Y2, Y15, Y11     // c46285a7da
+       //TODO: VFMSUBADD213PD Y11, Y15, Y11    // c44285a7db
+       //TODO: VFMSUBADD213PS (BX), X9, X2     // c4e231a713
+       //TODO: VFMSUBADD213PS (R11), X9, X2    // c4c231a713
+       //TODO: VFMSUBADD213PS X2, X9, X2       // c4e231a7d2
+       //TODO: VFMSUBADD213PS X11, X9, X2      // c4c231a7d3
+       //TODO: VFMSUBADD213PS (BX), X9, X11    // c46231a71b
+       //TODO: VFMSUBADD213PS (R11), X9, X11   // c44231a71b
+       //TODO: VFMSUBADD213PS X2, X9, X11      // c46231a7da
+       //TODO: VFMSUBADD213PS X11, X9, X11     // c44231a7db
+       //TODO: VFMSUBADD213PS (BX), Y15, Y2    // c4e205a713
+       //TODO: VFMSUBADD213PS (R11), Y15, Y2   // c4c205a713
+       //TODO: VFMSUBADD213PS Y2, Y15, Y2      // c4e205a7d2
+       //TODO: VFMSUBADD213PS Y11, Y15, Y2     // c4c205a7d3
+       //TODO: VFMSUBADD213PS (BX), Y15, Y11   // c46205a71b
+       //TODO: VFMSUBADD213PS (R11), Y15, Y11  // c44205a71b
+       //TODO: VFMSUBADD213PS Y2, Y15, Y11     // c46205a7da
+       //TODO: VFMSUBADD213PS Y11, Y15, Y11    // c44205a7db
+       //TODO: VFMSUBADD231PD (BX), X9, X2     // c4e2b1b713
+       //TODO: VFMSUBADD231PD (R11), X9, X2    // c4c2b1b713
+       //TODO: VFMSUBADD231PD X2, X9, X2       // c4e2b1b7d2
+       //TODO: VFMSUBADD231PD X11, X9, X2      // c4c2b1b7d3
+       //TODO: VFMSUBADD231PD (BX), X9, X11    // c462b1b71b
+       //TODO: VFMSUBADD231PD (R11), X9, X11   // c442b1b71b
+       //TODO: VFMSUBADD231PD X2, X9, X11      // c462b1b7da
+       //TODO: VFMSUBADD231PD X11, X9, X11     // c442b1b7db
+       //TODO: VFMSUBADD231PD (BX), Y15, Y2    // c4e285b713
+       //TODO: VFMSUBADD231PD (R11), Y15, Y2   // c4c285b713
+       //TODO: VFMSUBADD231PD Y2, Y15, Y2      // c4e285b7d2
+       //TODO: VFMSUBADD231PD Y11, Y15, Y2     // c4c285b7d3
+       //TODO: VFMSUBADD231PD (BX), Y15, Y11   // c46285b71b
+       //TODO: VFMSUBADD231PD (R11), Y15, Y11  // c44285b71b
+       //TODO: VFMSUBADD231PD Y2, Y15, Y11     // c46285b7da
+       //TODO: VFMSUBADD231PD Y11, Y15, Y11    // c44285b7db
+       //TODO: VFMSUBADD231PS (BX), X9, X2     // c4e231b713
+       //TODO: VFMSUBADD231PS (R11), X9, X2    // c4c231b713
+       //TODO: VFMSUBADD231PS X2, X9, X2       // c4e231b7d2
+       //TODO: VFMSUBADD231PS X11, X9, X2      // c4c231b7d3
+       //TODO: VFMSUBADD231PS (BX), X9, X11    // c46231b71b
+       //TODO: VFMSUBADD231PS (R11), X9, X11   // c44231b71b
+       //TODO: VFMSUBADD231PS X2, X9, X11      // c46231b7da
+       //TODO: VFMSUBADD231PS X11, X9, X11     // c44231b7db
+       //TODO: VFMSUBADD231PS (BX), Y15, Y2    // c4e205b713
+       //TODO: VFMSUBADD231PS (R11), Y15, Y2   // c4c205b713
+       //TODO: VFMSUBADD231PS Y2, Y15, Y2      // c4e205b7d2
+       //TODO: VFMSUBADD231PS Y11, Y15, Y2     // c4c205b7d3
+       //TODO: VFMSUBADD231PS (BX), Y15, Y11   // c46205b71b
+       //TODO: VFMSUBADD231PS (R11), Y15, Y11  // c44205b71b
+       //TODO: VFMSUBADD231PS Y2, Y15, Y11     // c46205b7da
+       //TODO: VFMSUBADD231PS Y11, Y15, Y11    // c44205b7db
+       //TODO: VFNMADD132PD (BX), X9, X2       // c4e2b19c13
+       //TODO: VFNMADD132PD (R11), X9, X2      // c4c2b19c13
+       //TODO: VFNMADD132PD X2, X9, X2         // c4e2b19cd2
+       //TODO: VFNMADD132PD X11, X9, X2        // c4c2b19cd3
+       //TODO: VFNMADD132PD (BX), X9, X11      // c462b19c1b
+       //TODO: VFNMADD132PD (R11), X9, X11     // c442b19c1b
+       //TODO: VFNMADD132PD X2, X9, X11        // c462b19cda
+       //TODO: VFNMADD132PD X11, X9, X11       // c442b19cdb
+       //TODO: VFNMADD132PD (BX), Y15, Y2      // c4e2859c13
+       //TODO: VFNMADD132PD (R11), Y15, Y2     // c4c2859c13
+       //TODO: VFNMADD132PD Y2, Y15, Y2        // c4e2859cd2
+       //TODO: VFNMADD132PD Y11, Y15, Y2       // c4c2859cd3
+       //TODO: VFNMADD132PD (BX), Y15, Y11     // c462859c1b
+       //TODO: VFNMADD132PD (R11), Y15, Y11    // c442859c1b
+       //TODO: VFNMADD132PD Y2, Y15, Y11       // c462859cda
+       //TODO: VFNMADD132PD Y11, Y15, Y11      // c442859cdb
+       //TODO: VFNMADD132PS (BX), X9, X2       // c4e2319c13
+       //TODO: VFNMADD132PS (R11), X9, X2      // c4c2319c13
+       //TODO: VFNMADD132PS X2, X9, X2         // c4e2319cd2
+       //TODO: VFNMADD132PS X11, X9, X2        // c4c2319cd3
+       //TODO: VFNMADD132PS (BX), X9, X11      // c462319c1b
+       //TODO: VFNMADD132PS (R11), X9, X11     // c442319c1b
+       //TODO: VFNMADD132PS X2, X9, X11        // c462319cda
+       //TODO: VFNMADD132PS X11, X9, X11       // c442319cdb
+       //TODO: VFNMADD132PS (BX), Y15, Y2      // c4e2059c13
+       //TODO: VFNMADD132PS (R11), Y15, Y2     // c4c2059c13
+       //TODO: VFNMADD132PS Y2, Y15, Y2        // c4e2059cd2
+       //TODO: VFNMADD132PS Y11, Y15, Y2       // c4c2059cd3
+       //TODO: VFNMADD132PS (BX), Y15, Y11     // c462059c1b
+       //TODO: VFNMADD132PS (R11), Y15, Y11    // c442059c1b
+       //TODO: VFNMADD132PS Y2, Y15, Y11       // c462059cda
+       //TODO: VFNMADD132PS Y11, Y15, Y11      // c442059cdb
+       //TODO: VFNMADD132SD (BX), X9, X2       // c4e2b19d13
+       //TODO: VFNMADD132SD (R11), X9, X2      // c4c2b19d13
+       //TODO: VFNMADD132SD X2, X9, X2         // c4e2b19dd2
+       //TODO: VFNMADD132SD X11, X9, X2        // c4c2b19dd3
+       //TODO: VFNMADD132SD (BX), X9, X11      // c462b19d1b
+       //TODO: VFNMADD132SD (R11), X9, X11     // c442b19d1b
+       //TODO: VFNMADD132SD X2, X9, X11        // c462b19dda
+       //TODO: VFNMADD132SD X11, X9, X11       // c442b19ddb
+       //TODO: VFNMADD132SS (BX), X9, X2       // c4e2319d13
+       //TODO: VFNMADD132SS (R11), X9, X2      // c4c2319d13
+       //TODO: VFNMADD132SS X2, X9, X2         // c4e2319dd2
+       //TODO: VFNMADD132SS X11, X9, X2        // c4c2319dd3
+       //TODO: VFNMADD132SS (BX), X9, X11      // c462319d1b
+       //TODO: VFNMADD132SS (R11), X9, X11     // c442319d1b
+       //TODO: VFNMADD132SS X2, X9, X11        // c462319dda
+       //TODO: VFNMADD132SS X11, X9, X11       // c442319ddb
+       //TODO: VFNMADD213PD (BX), X9, X2       // c4e2b1ac13
+       //TODO: VFNMADD213PD (R11), X9, X2      // c4c2b1ac13
+       //TODO: VFNMADD213PD X2, X9, X2         // c4e2b1acd2
+       //TODO: VFNMADD213PD X11, X9, X2        // c4c2b1acd3
+       //TODO: VFNMADD213PD (BX), X9, X11      // c462b1ac1b
+       //TODO: VFNMADD213PD (R11), X9, X11     // c442b1ac1b
+       //TODO: VFNMADD213PD X2, X9, X11        // c462b1acda
+       //TODO: VFNMADD213PD X11, X9, X11       // c442b1acdb
+       //TODO: VFNMADD213PD (BX), Y15, Y2      // c4e285ac13
+       //TODO: VFNMADD213PD (R11), Y15, Y2     // c4c285ac13
+       //TODO: VFNMADD213PD Y2, Y15, Y2        // c4e285acd2
+       //TODO: VFNMADD213PD Y11, Y15, Y2       // c4c285acd3
+       //TODO: VFNMADD213PD (BX), Y15, Y11     // c46285ac1b
+       //TODO: VFNMADD213PD (R11), Y15, Y11    // c44285ac1b
+       //TODO: VFNMADD213PD Y2, Y15, Y11       // c46285acda
+       //TODO: VFNMADD213PD Y11, Y15, Y11      // c44285acdb
+       //TODO: VFNMADD213PS (BX), X9, X2       // c4e231ac13
+       //TODO: VFNMADD213PS (R11), X9, X2      // c4c231ac13
+       //TODO: VFNMADD213PS X2, X9, X2         // c4e231acd2
+       //TODO: VFNMADD213PS X11, X9, X2        // c4c231acd3
+       //TODO: VFNMADD213PS (BX), X9, X11      // c46231ac1b
+       //TODO: VFNMADD213PS (R11), X9, X11     // c44231ac1b
+       //TODO: VFNMADD213PS X2, X9, X11        // c46231acda
+       //TODO: VFNMADD213PS X11, X9, X11       // c44231acdb
+       //TODO: VFNMADD213PS (BX), Y15, Y2      // c4e205ac13
+       //TODO: VFNMADD213PS (R11), Y15, Y2     // c4c205ac13
+       //TODO: VFNMADD213PS Y2, Y15, Y2        // c4e205acd2
+       //TODO: VFNMADD213PS Y11, Y15, Y2       // c4c205acd3
+       //TODO: VFNMADD213PS (BX), Y15, Y11     // c46205ac1b
+       //TODO: VFNMADD213PS (R11), Y15, Y11    // c44205ac1b
+       //TODO: VFNMADD213PS Y2, Y15, Y11       // c46205acda
+       //TODO: VFNMADD213PS Y11, Y15, Y11      // c44205acdb
+       //TODO: VFNMADD213SD (BX), X9, X2       // c4e2b1ad13
+       //TODO: VFNMADD213SD (R11), X9, X2      // c4c2b1ad13
+       //TODO: VFNMADD213SD X2, X9, X2         // c4e2b1add2
+       //TODO: VFNMADD213SD X11, X9, X2        // c4c2b1add3
+       //TODO: VFNMADD213SD (BX), X9, X11      // c462b1ad1b
+       //TODO: VFNMADD213SD (R11), X9, X11     // c442b1ad1b
+       //TODO: VFNMADD213SD X2, X9, X11        // c462b1adda
+       //TODO: VFNMADD213SD X11, X9, X11       // c442b1addb
+       //TODO: VFNMADD213SS (BX), X9, X2       // c4e231ad13
+       //TODO: VFNMADD213SS (R11), X9, X2      // c4c231ad13
+       //TODO: VFNMADD213SS X2, X9, X2         // c4e231add2
+       //TODO: VFNMADD213SS X11, X9, X2        // c4c231add3
+       //TODO: VFNMADD213SS (BX), X9, X11      // c46231ad1b
+       //TODO: VFNMADD213SS (R11), X9, X11     // c44231ad1b
+       //TODO: VFNMADD213SS X2, X9, X11        // c46231adda
+       //TODO: VFNMADD213SS X11, X9, X11       // c44231addb
+       //TODO: VFNMADD231PD (BX), X9, X2       // c4e2b1bc13
+       //TODO: VFNMADD231PD (R11), X9, X2      // c4c2b1bc13
+       //TODO: VFNMADD231PD X2, X9, X2         // c4e2b1bcd2
+       //TODO: VFNMADD231PD X11, X9, X2        // c4c2b1bcd3
+       //TODO: VFNMADD231PD (BX), X9, X11      // c462b1bc1b
+       //TODO: VFNMADD231PD (R11), X9, X11     // c442b1bc1b
+       //TODO: VFNMADD231PD X2, X9, X11        // c462b1bcda
+       //TODO: VFNMADD231PD X11, X9, X11       // c442b1bcdb
+       //TODO: VFNMADD231PD (BX), Y15, Y2      // c4e285bc13
+       //TODO: VFNMADD231PD (R11), Y15, Y2     // c4c285bc13
+       //TODO: VFNMADD231PD Y2, Y15, Y2        // c4e285bcd2
+       //TODO: VFNMADD231PD Y11, Y15, Y2       // c4c285bcd3
+       //TODO: VFNMADD231PD (BX), Y15, Y11     // c46285bc1b
+       //TODO: VFNMADD231PD (R11), Y15, Y11    // c44285bc1b
+       //TODO: VFNMADD231PD Y2, Y15, Y11       // c46285bcda
+       //TODO: VFNMADD231PD Y11, Y15, Y11      // c44285bcdb
+       //TODO: VFNMADD231PS (BX), X9, X2       // c4e231bc13
+       //TODO: VFNMADD231PS (R11), X9, X2      // c4c231bc13
+       //TODO: VFNMADD231PS X2, X9, X2         // c4e231bcd2
+       //TODO: VFNMADD231PS X11, X9, X2        // c4c231bcd3
+       //TODO: VFNMADD231PS (BX), X9, X11      // c46231bc1b
+       //TODO: VFNMADD231PS (R11), X9, X11     // c44231bc1b
+       //TODO: VFNMADD231PS X2, X9, X11        // c46231bcda
+       //TODO: VFNMADD231PS X11, X9, X11       // c44231bcdb
+       //TODO: VFNMADD231PS (BX), Y15, Y2      // c4e205bc13
+       //TODO: VFNMADD231PS (R11), Y15, Y2     // c4c205bc13
+       //TODO: VFNMADD231PS Y2, Y15, Y2        // c4e205bcd2
+       //TODO: VFNMADD231PS Y11, Y15, Y2       // c4c205bcd3
+       //TODO: VFNMADD231PS (BX), Y15, Y11     // c46205bc1b
+       //TODO: VFNMADD231PS (R11), Y15, Y11    // c44205bc1b
+       //TODO: VFNMADD231PS Y2, Y15, Y11       // c46205bcda
+       //TODO: VFNMADD231PS Y11, Y15, Y11      // c44205bcdb
+       //TODO: VFNMADD231SD (BX), X9, X2       // c4e2b1bd13
+       //TODO: VFNMADD231SD (R11), X9, X2      // c4c2b1bd13
+       //TODO: VFNMADD231SD X2, X9, X2         // c4e2b1bdd2
+       //TODO: VFNMADD231SD X11, X9, X2        // c4c2b1bdd3
+       //TODO: VFNMADD231SD (BX), X9, X11      // c462b1bd1b
+       //TODO: VFNMADD231SD (R11), X9, X11     // c442b1bd1b
+       //TODO: VFNMADD231SD X2, X9, X11        // c462b1bdda
+       //TODO: VFNMADD231SD X11, X9, X11       // c442b1bddb
+       //TODO: VFNMADD231SS (BX), X9, X2       // c4e231bd13
+       //TODO: VFNMADD231SS (R11), X9, X2      // c4c231bd13
+       //TODO: VFNMADD231SS X2, X9, X2         // c4e231bdd2
+       //TODO: VFNMADD231SS X11, X9, X2        // c4c231bdd3
+       //TODO: VFNMADD231SS (BX), X9, X11      // c46231bd1b
+       //TODO: VFNMADD231SS (R11), X9, X11     // c44231bd1b
+       //TODO: VFNMADD231SS X2, X9, X11        // c46231bdda
+       //TODO: VFNMADD231SS X11, X9, X11       // c44231bddb
+       //TODO: VFNMSUB132PD (BX), X9, X2       // c4e2b19e13
+       //TODO: VFNMSUB132PD (R11), X9, X2      // c4c2b19e13
+       //TODO: VFNMSUB132PD X2, X9, X2         // c4e2b19ed2
+       //TODO: VFNMSUB132PD X11, X9, X2        // c4c2b19ed3
+       //TODO: VFNMSUB132PD (BX), X9, X11      // c462b19e1b
+       //TODO: VFNMSUB132PD (R11), X9, X11     // c442b19e1b
+       //TODO: VFNMSUB132PD X2, X9, X11        // c462b19eda
+       //TODO: VFNMSUB132PD X11, X9, X11       // c442b19edb
+       //TODO: VFNMSUB132PD (BX), Y15, Y2      // c4e2859e13
+       //TODO: VFNMSUB132PD (R11), Y15, Y2     // c4c2859e13
+       //TODO: VFNMSUB132PD Y2, Y15, Y2        // c4e2859ed2
+       //TODO: VFNMSUB132PD Y11, Y15, Y2       // c4c2859ed3
+       //TODO: VFNMSUB132PD (BX), Y15, Y11     // c462859e1b
+       //TODO: VFNMSUB132PD (R11), Y15, Y11    // c442859e1b
+       //TODO: VFNMSUB132PD Y2, Y15, Y11       // c462859eda
+       //TODO: VFNMSUB132PD Y11, Y15, Y11      // c442859edb
+       //TODO: VFNMSUB132PS (BX), X9, X2       // c4e2319e13
+       //TODO: VFNMSUB132PS (R11), X9, X2      // c4c2319e13
+       //TODO: VFNMSUB132PS X2, X9, X2         // c4e2319ed2
+       //TODO: VFNMSUB132PS X11, X9, X2        // c4c2319ed3
+       //TODO: VFNMSUB132PS (BX), X9, X11      // c462319e1b
+       //TODO: VFNMSUB132PS (R11), X9, X11     // c442319e1b
+       //TODO: VFNMSUB132PS X2, X9, X11        // c462319eda
+       //TODO: VFNMSUB132PS X11, X9, X11       // c442319edb
+       //TODO: VFNMSUB132PS (BX), Y15, Y2      // c4e2059e13
+       //TODO: VFNMSUB132PS (R11), Y15, Y2     // c4c2059e13
+       //TODO: VFNMSUB132PS Y2, Y15, Y2        // c4e2059ed2
+       //TODO: VFNMSUB132PS Y11, Y15, Y2       // c4c2059ed3
+       //TODO: VFNMSUB132PS (BX), Y15, Y11     // c462059e1b
+       //TODO: VFNMSUB132PS (R11), Y15, Y11    // c442059e1b
+       //TODO: VFNMSUB132PS Y2, Y15, Y11       // c462059eda
+       //TODO: VFNMSUB132PS Y11, Y15, Y11      // c442059edb
+       //TODO: VFNMSUB132SD (BX), X9, X2       // c4e2b19f13
+       //TODO: VFNMSUB132SD (R11), X9, X2      // c4c2b19f13
+       //TODO: VFNMSUB132SD X2, X9, X2         // c4e2b19fd2
+       //TODO: VFNMSUB132SD X11, X9, X2        // c4c2b19fd3
+       //TODO: VFNMSUB132SD (BX), X9, X11      // c462b19f1b
+       //TODO: VFNMSUB132SD (R11), X9, X11     // c442b19f1b
+       //TODO: VFNMSUB132SD X2, X9, X11        // c462b19fda
+       //TODO: VFNMSUB132SD X11, X9, X11       // c442b19fdb
+       //TODO: VFNMSUB132SS (BX), X9, X2       // c4e2319f13
+       //TODO: VFNMSUB132SS (R11), X9, X2      // c4c2319f13
+       //TODO: VFNMSUB132SS X2, X9, X2         // c4e2319fd2
+       //TODO: VFNMSUB132SS X11, X9, X2        // c4c2319fd3
+       //TODO: VFNMSUB132SS (BX), X9, X11      // c462319f1b
+       //TODO: VFNMSUB132SS (R11), X9, X11     // c442319f1b
+       //TODO: VFNMSUB132SS X2, X9, X11        // c462319fda
+       //TODO: VFNMSUB132SS X11, X9, X11       // c442319fdb
+       //TODO: VFNMSUB213PD (BX), X9, X2       // c4e2b1ae13
+       //TODO: VFNMSUB213PD (R11), X9, X2      // c4c2b1ae13
+       //TODO: VFNMSUB213PD X2, X9, X2         // c4e2b1aed2
+       //TODO: VFNMSUB213PD X11, X9, X2        // c4c2b1aed3
+       //TODO: VFNMSUB213PD (BX), X9, X11      // c462b1ae1b
+       //TODO: VFNMSUB213PD (R11), X9, X11     // c442b1ae1b
+       //TODO: VFNMSUB213PD X2, X9, X11        // c462b1aeda
+       //TODO: VFNMSUB213PD X11, X9, X11       // c442b1aedb
+       //TODO: VFNMSUB213PD (BX), Y15, Y2      // c4e285ae13
+       //TODO: VFNMSUB213PD (R11), Y15, Y2     // c4c285ae13
+       //TODO: VFNMSUB213PD Y2, Y15, Y2        // c4e285aed2
+       //TODO: VFNMSUB213PD Y11, Y15, Y2       // c4c285aed3
+       //TODO: VFNMSUB213PD (BX), Y15, Y11     // c46285ae1b
+       //TODO: VFNMSUB213PD (R11), Y15, Y11    // c44285ae1b
+       //TODO: VFNMSUB213PD Y2, Y15, Y11       // c46285aeda
+       //TODO: VFNMSUB213PD Y11, Y15, Y11      // c44285aedb
+       //TODO: VFNMSUB213PS (BX), X9, X2       // c4e231ae13
+       //TODO: VFNMSUB213PS (R11), X9, X2      // c4c231ae13
+       //TODO: VFNMSUB213PS X2, X9, X2         // c4e231aed2
+       //TODO: VFNMSUB213PS X11, X9, X2        // c4c231aed3
+       //TODO: VFNMSUB213PS (BX), X9, X11      // c46231ae1b
+       //TODO: VFNMSUB213PS (R11), X9, X11     // c44231ae1b
+       //TODO: VFNMSUB213PS X2, X9, X11        // c46231aeda
+       //TODO: VFNMSUB213PS X11, X9, X11       // c44231aedb
+       //TODO: VFNMSUB213PS (BX), Y15, Y2      // c4e205ae13
+       //TODO: VFNMSUB213PS (R11), Y15, Y2     // c4c205ae13
+       //TODO: VFNMSUB213PS Y2, Y15, Y2        // c4e205aed2
+       //TODO: VFNMSUB213PS Y11, Y15, Y2       // c4c205aed3
+       //TODO: VFNMSUB213PS (BX), Y15, Y11     // c46205ae1b
+       //TODO: VFNMSUB213PS (R11), Y15, Y11    // c44205ae1b
+       //TODO: VFNMSUB213PS Y2, Y15, Y11       // c46205aeda
+       //TODO: VFNMSUB213PS Y11, Y15, Y11      // c44205aedb
+       //TODO: VFNMSUB213SD (BX), X9, X2       // c4e2b1af13
+       //TODO: VFNMSUB213SD (R11), X9, X2      // c4c2b1af13
+       //TODO: VFNMSUB213SD X2, X9, X2         // c4e2b1afd2
+       //TODO: VFNMSUB213SD X11, X9, X2        // c4c2b1afd3
+       //TODO: VFNMSUB213SD (BX), X9, X11      // c462b1af1b
+       //TODO: VFNMSUB213SD (R11), X9, X11     // c442b1af1b
+       //TODO: VFNMSUB213SD X2, X9, X11        // c462b1afda
+       //TODO: VFNMSUB213SD X11, X9, X11       // c442b1afdb
+       //TODO: VFNMSUB213SS (BX), X9, X2       // c4e231af13
+       //TODO: VFNMSUB213SS (R11), X9, X2      // c4c231af13
+       //TODO: VFNMSUB213SS X2, X9, X2         // c4e231afd2
+       //TODO: VFNMSUB213SS X11, X9, X2        // c4c231afd3
+       //TODO: VFNMSUB213SS (BX), X9, X11      // c46231af1b
+       //TODO: VFNMSUB213SS (R11), X9, X11     // c44231af1b
+       //TODO: VFNMSUB213SS X2, X9, X11        // c46231afda
+       //TODO: VFNMSUB213SS X11, X9, X11       // c44231afdb
+       //TODO: VFNMSUB231PD (BX), X9, X2       // c4e2b1be13
+       //TODO: VFNMSUB231PD (R11), X9, X2      // c4c2b1be13
+       //TODO: VFNMSUB231PD X2, X9, X2         // c4e2b1bed2
+       //TODO: VFNMSUB231PD X11, X9, X2        // c4c2b1bed3
+       //TODO: VFNMSUB231PD (BX), X9, X11      // c462b1be1b
+       //TODO: VFNMSUB231PD (R11), X9, X11     // c442b1be1b
+       //TODO: VFNMSUB231PD X2, X9, X11        // c462b1beda
+       //TODO: VFNMSUB231PD X11, X9, X11       // c442b1bedb
+       //TODO: VFNMSUB231PD (BX), Y15, Y2      // c4e285be13
+       //TODO: VFNMSUB231PD (R11), Y15, Y2     // c4c285be13
+       //TODO: VFNMSUB231PD Y2, Y15, Y2        // c4e285bed2
+       //TODO: VFNMSUB231PD Y11, Y15, Y2       // c4c285bed3
+       //TODO: VFNMSUB231PD (BX), Y15, Y11     // c46285be1b
+       //TODO: VFNMSUB231PD (R11), Y15, Y11    // c44285be1b
+       //TODO: VFNMSUB231PD Y2, Y15, Y11       // c46285beda
+       //TODO: VFNMSUB231PD Y11, Y15, Y11      // c44285bedb
+       //TODO: VFNMSUB231PS (BX), X9, X2       // c4e231be13
+       //TODO: VFNMSUB231PS (R11), X9, X2      // c4c231be13
+       //TODO: VFNMSUB231PS X2, X9, X2         // c4e231bed2
+       //TODO: VFNMSUB231PS X11, X9, X2        // c4c231bed3
+       //TODO: VFNMSUB231PS (BX), X9, X11      // c46231be1b
+       //TODO: VFNMSUB231PS (R11), X9, X11     // c44231be1b
+       //TODO: VFNMSUB231PS X2, X9, X11        // c46231beda
+       //TODO: VFNMSUB231PS X11, X9, X11       // c44231bedb
+       //TODO: VFNMSUB231PS (BX), Y15, Y2      // c4e205be13
+       //TODO: VFNMSUB231PS (R11), Y15, Y2     // c4c205be13
+       //TODO: VFNMSUB231PS Y2, Y15, Y2        // c4e205bed2
+       //TODO: VFNMSUB231PS Y11, Y15, Y2       // c4c205bed3
+       //TODO: VFNMSUB231PS (BX), Y15, Y11     // c46205be1b
+       //TODO: VFNMSUB231PS (R11), Y15, Y11    // c44205be1b
+       //TODO: VFNMSUB231PS Y2, Y15, Y11       // c46205beda
+       //TODO: VFNMSUB231PS Y11, Y15, Y11      // c44205bedb
+       //TODO: VFNMSUB231SD (BX), X9, X2       // c4e2b1bf13
+       //TODO: VFNMSUB231SD (R11), X9, X2      // c4c2b1bf13
+       //TODO: VFNMSUB231SD X2, X9, X2         // c4e2b1bfd2
+       //TODO: VFNMSUB231SD X11, X9, X2        // c4c2b1bfd3
+       //TODO: VFNMSUB231SD (BX), X9, X11      // c462b1bf1b
+       //TODO: VFNMSUB231SD (R11), X9, X11     // c442b1bf1b
+       //TODO: VFNMSUB231SD X2, X9, X11        // c462b1bfda
+       //TODO: VFNMSUB231SD X11, X9, X11       // c442b1bfdb
+       //TODO: VFNMSUB231SS (BX), X9, X2       // c4e231bf13
+       //TODO: VFNMSUB231SS (R11), X9, X2      // c4c231bf13
+       //TODO: VFNMSUB231SS X2, X9, X2         // c4e231bfd2
+       //TODO: VFNMSUB231SS X11, X9, X2        // c4c231bfd3
+       //TODO: VFNMSUB231SS (BX), X9, X11      // c46231bf1b
+       //TODO: VFNMSUB231SS (R11), X9, X11     // c44231bf1b
+       //TODO: VFNMSUB231SS X2, X9, X11        // c46231bfda
+       //TODO: VFNMSUB231SS X11, X9, X11       // c44231bfdb
+       //TODO: VHADDPD (BX), X9, X2            // c4e1317c13 or c5b17c13
+       //TODO: VHADDPD (R11), X9, X2           // c4c1317c13
+       //TODO: VHADDPD X2, X9, X2              // c4e1317cd2 or c5b17cd2
+       //TODO: VHADDPD X11, X9, X2             // c4c1317cd3
+       //TODO: VHADDPD (BX), X9, X11           // c461317c1b or c5317c1b
+       //TODO: VHADDPD (R11), X9, X11          // c441317c1b
+       //TODO: VHADDPD X2, X9, X11             // c461317cda or c5317cda
+       //TODO: VHADDPD X11, X9, X11            // c441317cdb
+       //TODO: VHADDPD (BX), Y15, Y2           // c4e1057c13 or c5857c13
+       //TODO: VHADDPD (R11), Y15, Y2          // c4c1057c13
+       //TODO: VHADDPD Y2, Y15, Y2             // c4e1057cd2 or c5857cd2
+       //TODO: VHADDPD Y11, Y15, Y2            // c4c1057cd3
+       //TODO: VHADDPD (BX), Y15, Y11          // c461057c1b or c5057c1b
+       //TODO: VHADDPD (R11), Y15, Y11         // c441057c1b
+       //TODO: VHADDPD Y2, Y15, Y11            // c461057cda or c5057cda
+       //TODO: VHADDPD Y11, Y15, Y11           // c441057cdb
+       //TODO: VHADDPS (BX), X9, X2            // c4e1337c13 or c5b37c13
+       //TODO: VHADDPS (R11), X9, X2           // c4c1337c13
+       //TODO: VHADDPS X2, X9, X2              // c4e1337cd2 or c5b37cd2
+       //TODO: VHADDPS X11, X9, X2             // c4c1337cd3
+       //TODO: VHADDPS (BX), X9, X11           // c461337c1b or c5337c1b
+       //TODO: VHADDPS (R11), X9, X11          // c441337c1b
+       //TODO: VHADDPS X2, X9, X11             // c461337cda or c5337cda
+       //TODO: VHADDPS X11, X9, X11            // c441337cdb
+       //TODO: VHADDPS (BX), Y15, Y2           // c4e1077c13 or c5877c13
+       //TODO: VHADDPS (R11), Y15, Y2          // c4c1077c13
+       //TODO: VHADDPS Y2, Y15, Y2             // c4e1077cd2 or c5877cd2
+       //TODO: VHADDPS Y11, Y15, Y2            // c4c1077cd3
+       //TODO: VHADDPS (BX), Y15, Y11          // c461077c1b or c5077c1b
+       //TODO: VHADDPS (R11), Y15, Y11         // c441077c1b
+       //TODO: VHADDPS Y2, Y15, Y11            // c461077cda or c5077cda
+       //TODO: VHADDPS Y11, Y15, Y11           // c441077cdb
+       //TODO: VHSUBPD (BX), X9, X2            // c4e1317d13 or c5b17d13
+       //TODO: VHSUBPD (R11), X9, X2           // c4c1317d13
+       //TODO: VHSUBPD X2, X9, X2              // c4e1317dd2 or c5b17dd2
+       //TODO: VHSUBPD X11, X9, X2             // c4c1317dd3
+       //TODO: VHSUBPD (BX), X9, X11           // c461317d1b or c5317d1b
+       //TODO: VHSUBPD (R11), X9, X11          // c441317d1b
+       //TODO: VHSUBPD X2, X9, X11             // c461317dda or c5317dda
+       //TODO: VHSUBPD X11, X9, X11            // c441317ddb
+       //TODO: VHSUBPD (BX), Y15, Y2           // c4e1057d13 or c5857d13
+       //TODO: VHSUBPD (R11), Y15, Y2          // c4c1057d13
+       //TODO: VHSUBPD Y2, Y15, Y2             // c4e1057dd2 or c5857dd2
+       //TODO: VHSUBPD Y11, Y15, Y2            // c4c1057dd3
+       //TODO: VHSUBPD (BX), Y15, Y11          // c461057d1b or c5057d1b
+       //TODO: VHSUBPD (R11), Y15, Y11         // c441057d1b
+       //TODO: VHSUBPD Y2, Y15, Y11            // c461057dda or c5057dda
+       //TODO: VHSUBPD Y11, Y15, Y11           // c441057ddb
+       //TODO: VHSUBPS (BX), X9, X2            // c4e1337d13 or c5b37d13
+       //TODO: VHSUBPS (R11), X9, X2           // c4c1337d13
+       //TODO: VHSUBPS X2, X9, X2              // c4e1337dd2 or c5b37dd2
+       //TODO: VHSUBPS X11, X9, X2             // c4c1337dd3
+       //TODO: VHSUBPS (BX), X9, X11           // c461337d1b or c5337d1b
+       //TODO: VHSUBPS (R11), X9, X11          // c441337d1b
+       //TODO: VHSUBPS X2, X9, X11             // c461337dda or c5337dda
+       //TODO: VHSUBPS X11, X9, X11            // c441337ddb
+       //TODO: VHSUBPS (BX), Y15, Y2           // c4e1077d13 or c5877d13
+       //TODO: VHSUBPS (R11), Y15, Y2          // c4c1077d13
+       //TODO: VHSUBPS Y2, Y15, Y2             // c4e1077dd2 or c5877dd2
+       //TODO: VHSUBPS Y11, Y15, Y2            // c4c1077dd3
+       //TODO: VHSUBPS (BX), Y15, Y11          // c461077d1b or c5077d1b
+       //TODO: VHSUBPS (R11), Y15, Y11         // c441077d1b
+       //TODO: VHSUBPS Y2, Y15, Y11            // c461077dda or c5077dda
+       //TODO: VHSUBPS Y11, Y15, Y11           // c441077ddb
+       //TODO: VINSERTF128 $7, (BX), Y15, Y2   // c4e305181307
+       //TODO: VINSERTF128 $7, (R11), Y15, Y2  // c4c305181307
+       //TODO: VINSERTF128 $7, X2, Y15, Y2     // c4e30518d207
+       //TODO: VINSERTF128 $7, X11, Y15, Y2    // c4c30518d307
+       //TODO: VINSERTF128 $7, (BX), Y15, Y11  // c46305181b07
+       //TODO: VINSERTF128 $7, (R11), Y15, Y11 // c44305181b07
+       //TODO: VINSERTF128 $7, X2, Y15, Y11    // c4630518da07
+       //TODO: VINSERTF128 $7, X11, Y15, Y11   // c4430518db07
+       //TODO: VINSERTI128 $7, (BX), Y15, Y2   // c4e305381307
+       //TODO: VINSERTI128 $7, (R11), Y15, Y2  // c4c305381307
+       //TODO: VINSERTI128 $7, X2, Y15, Y2     // c4e30538d207
+       //TODO: VINSERTI128 $7, X11, Y15, Y2    // c4c30538d307
+       //TODO: VINSERTI128 $7, (BX), Y15, Y11  // c46305381b07
+       //TODO: VINSERTI128 $7, (R11), Y15, Y11 // c44305381b07
+       //TODO: VINSERTI128 $7, X2, Y15, Y11    // c4630538da07
+       //TODO: VINSERTI128 $7, X11, Y15, Y11   // c4430538db07
+       //TODO: VINSERTPS $7, (BX), X9, X2      // c4e331211307
+       //TODO: VINSERTPS $7, (R11), X9, X2     // c4c331211307
+       //TODO: VINSERTPS $7, X2, X9, X2        // c4e33121d207
+       //TODO: VINSERTPS $7, X11, X9, X2       // c4c33121d307
+       //TODO: VINSERTPS $7, (BX), X9, X11     // c46331211b07
+       //TODO: VINSERTPS $7, (R11), X9, X11    // c44331211b07
+       //TODO: VINSERTPS $7, X2, X9, X11       // c4633121da07
+       //TODO: VINSERTPS $7, X11, X9, X11      // c4433121db07
+       //TODO: VLDDQU (BX), X2                 // c4e17bf013 or c5fbf013
+       //TODO: VLDDQU (R11), X2                // c4c17bf013
+       //TODO: VLDDQU (BX), X11                // c4617bf01b or c57bf01b
+       //TODO: VLDDQU (R11), X11               // c4417bf01b
+       //TODO: VLDDQU (BX), Y2                 // c4e17ff013 or c5fff013
+       //TODO: VLDDQU (R11), Y2                // c4c17ff013
+       //TODO: VLDDQU (BX), Y11                // c4617ff01b or c57ff01b
+       //TODO: VLDDQU (R11), Y11               // c4417ff01b
+       //TODO: VLDMXCSR (BX)                   // c4e178ae13 or c5f8ae13
+       //TODO: VLDMXCSR (R11)                  // c4c178ae13
+       //TODO: VMASKMOVDQU X2, X2              // c4e179f7d2 or c5f9f7d2
+       //TODO: VMASKMOVDQU X11, X2             // c4c179f7d3
+       //TODO: VMASKMOVDQU X2, X11             // c46179f7da or c579f7da
+       //TODO: VMASKMOVDQU X11, X11            // c44179f7db
+       //TODO: VMASKMOVPD X2, X9, (BX)         // c4e2312f13
+       //TODO: VMASKMOVPD X11, X9, (BX)        // c462312f1b
+       //TODO: VMASKMOVPD X2, X9, (R11)        // c4c2312f13
+       //TODO: VMASKMOVPD X11, X9, (R11)       // c442312f1b
+       //TODO: VMASKMOVPD Y2, Y15, (BX)        // c4e2052f13
+       //TODO: VMASKMOVPD Y11, Y15, (BX)       // c462052f1b
+       //TODO: VMASKMOVPD Y2, Y15, (R11)       // c4c2052f13
+       //TODO: VMASKMOVPD Y11, Y15, (R11)      // c442052f1b
+       //TODO: VMASKMOVPD (BX), X9, X2         // c4e2312d13
+       //TODO: VMASKMOVPD (R11), X9, X2        // c4c2312d13
+       //TODO: VMASKMOVPD (BX), X9, X11        // c462312d1b
+       //TODO: VMASKMOVPD (R11), X9, X11       // c442312d1b
+       //TODO: VMASKMOVPD (BX), Y15, Y2        // c4e2052d13
+       //TODO: VMASKMOVPD (R11), Y15, Y2       // c4c2052d13
+       //TODO: VMASKMOVPD (BX), Y15, Y11       // c462052d1b
+       //TODO: VMASKMOVPD (R11), Y15, Y11      // c442052d1b
+       //TODO: VMASKMOVPS X2, X9, (BX)         // c4e2312e13
+       //TODO: VMASKMOVPS X11, X9, (BX)        // c462312e1b
+       //TODO: VMASKMOVPS X2, X9, (R11)        // c4c2312e13
+       //TODO: VMASKMOVPS X11, X9, (R11)       // c442312e1b
+       //TODO: VMASKMOVPS Y2, Y15, (BX)        // c4e2052e13
+       //TODO: VMASKMOVPS Y11, Y15, (BX)       // c462052e1b
+       //TODO: VMASKMOVPS Y2, Y15, (R11)       // c4c2052e13
+       //TODO: VMASKMOVPS Y11, Y15, (R11)      // c442052e1b
+       //TODO: VMASKMOVPS (BX), X9, X2         // c4e2312c13
+       //TODO: VMASKMOVPS (R11), X9, X2        // c4c2312c13
+       //TODO: VMASKMOVPS (BX), X9, X11        // c462312c1b
+       //TODO: VMASKMOVPS (R11), X9, X11       // c442312c1b
+       //TODO: VMASKMOVPS (BX), Y15, Y2        // c4e2052c13
+       //TODO: VMASKMOVPS (R11), Y15, Y2       // c4c2052c13
+       //TODO: VMASKMOVPS (BX), Y15, Y11       // c462052c1b
+       //TODO: VMASKMOVPS (R11), Y15, Y11      // c442052c1b
+       //TODO: VMAXPD (BX), X9, X2             // c4e1315f13 or c5b15f13
+       //TODO: VMAXPD (R11), X9, X2            // c4c1315f13
+       //TODO: VMAXPD X2, X9, X2               // c4e1315fd2 or c5b15fd2
+       //TODO: VMAXPD X11, X9, X2              // c4c1315fd3
+       //TODO: VMAXPD (BX), X9, X11            // c461315f1b or c5315f1b
+       //TODO: VMAXPD (R11), X9, X11           // c441315f1b
+       //TODO: VMAXPD X2, X9, X11              // c461315fda or c5315fda
+       //TODO: VMAXPD X11, X9, X11             // c441315fdb
+       //TODO: VMAXPD (BX), Y15, Y2            // c4e1055f13 or c5855f13
+       //TODO: VMAXPD (R11), Y15, Y2           // c4c1055f13
+       //TODO: VMAXPD Y2, Y15, Y2              // c4e1055fd2 or c5855fd2
+       //TODO: VMAXPD Y11, Y15, Y2             // c4c1055fd3
+       //TODO: VMAXPD (BX), Y15, Y11           // c461055f1b or c5055f1b
+       //TODO: VMAXPD (R11), Y15, Y11          // c441055f1b
+       //TODO: VMAXPD Y2, Y15, Y11             // c461055fda or c5055fda
+       //TODO: VMAXPD Y11, Y15, Y11            // c441055fdb
+       //TODO: VMAXPS (BX), X9, X2             // c4e1305f13 or c5b05f13
+       //TODO: VMAXPS (R11), X9, X2            // c4c1305f13
+       //TODO: VMAXPS X2, X9, X2               // c4e1305fd2 or c5b05fd2
+       //TODO: VMAXPS X11, X9, X2              // c4c1305fd3
+       //TODO: VMAXPS (BX), X9, X11            // c461305f1b or c5305f1b
+       //TODO: VMAXPS (R11), X9, X11           // c441305f1b
+       //TODO: VMAXPS X2, X9, X11              // c461305fda or c5305fda
+       //TODO: VMAXPS X11, X9, X11             // c441305fdb
+       //TODO: VMAXPS (BX), Y15, Y2            // c4e1045f13 or c5845f13
+       //TODO: VMAXPS (R11), Y15, Y2           // c4c1045f13
+       //TODO: VMAXPS Y2, Y15, Y2              // c4e1045fd2 or c5845fd2
+       //TODO: VMAXPS Y11, Y15, Y2             // c4c1045fd3
+       //TODO: VMAXPS (BX), Y15, Y11           // c461045f1b or c5045f1b
+       //TODO: VMAXPS (R11), Y15, Y11          // c441045f1b
+       //TODO: VMAXPS Y2, Y15, Y11             // c461045fda or c5045fda
+       //TODO: VMAXPS Y11, Y15, Y11            // c441045fdb
+       //TODO: VMAXSD (BX), X9, X2             // c4e1335f13 or c5b35f13
+       //TODO: VMAXSD (R11), X9, X2            // c4c1335f13
+       //TODO: VMAXSD X2, X9, X2               // c4e1335fd2 or c5b35fd2
+       //TODO: VMAXSD X11, X9, X2              // c4c1335fd3
+       //TODO: VMAXSD (BX), X9, X11            // c461335f1b or c5335f1b
+       //TODO: VMAXSD (R11), X9, X11           // c441335f1b
+       //TODO: VMAXSD X2, X9, X11              // c461335fda or c5335fda
+       //TODO: VMAXSD X11, X9, X11             // c441335fdb
+       //TODO: VMAXSS (BX), X9, X2             // c4e1325f13 or c5b25f13
+       //TODO: VMAXSS (R11), X9, X2            // c4c1325f13
+       //TODO: VMAXSS X2, X9, X2               // c4e1325fd2 or c5b25fd2
+       //TODO: VMAXSS X11, X9, X2              // c4c1325fd3
+       //TODO: VMAXSS (BX), X9, X11            // c461325f1b or c5325f1b
+       //TODO: VMAXSS (R11), X9, X11           // c441325f1b
+       //TODO: VMAXSS X2, X9, X11              // c461325fda or c5325fda
+       //TODO: VMAXSS X11, X9, X11             // c441325fdb
+       //TODO: VMINPD (BX), X9, X2             // c4e1315d13 or c5b15d13
+       //TODO: VMINPD (R11), X9, X2            // c4c1315d13
+       //TODO: VMINPD X2, X9, X2               // c4e1315dd2 or c5b15dd2
+       //TODO: VMINPD X11, X9, X2              // c4c1315dd3
+       //TODO: VMINPD (BX), X9, X11            // c461315d1b or c5315d1b
+       //TODO: VMINPD (R11), X9, X11           // c441315d1b
+       //TODO: VMINPD X2, X9, X11              // c461315dda or c5315dda
+       //TODO: VMINPD X11, X9, X11             // c441315ddb
+       //TODO: VMINPD (BX), Y15, Y2            // c4e1055d13 or c5855d13
+       //TODO: VMINPD (R11), Y15, Y2           // c4c1055d13
+       //TODO: VMINPD Y2, Y15, Y2              // c4e1055dd2 or c5855dd2
+       //TODO: VMINPD Y11, Y15, Y2             // c4c1055dd3
+       //TODO: VMINPD (BX), Y15, Y11           // c461055d1b or c5055d1b
+       //TODO: VMINPD (R11), Y15, Y11          // c441055d1b
+       //TODO: VMINPD Y2, Y15, Y11             // c461055dda or c5055dda
+       //TODO: VMINPD Y11, Y15, Y11            // c441055ddb
+       //TODO: VMINPS (BX), X9, X2             // c4e1305d13 or c5b05d13
+       //TODO: VMINPS (R11), X9, X2            // c4c1305d13
+       //TODO: VMINPS X2, X9, X2               // c4e1305dd2 or c5b05dd2
+       //TODO: VMINPS X11, X9, X2              // c4c1305dd3
+       //TODO: VMINPS (BX), X9, X11            // c461305d1b or c5305d1b
+       //TODO: VMINPS (R11), X9, X11           // c441305d1b
+       //TODO: VMINPS X2, X9, X11              // c461305dda or c5305dda
+       //TODO: VMINPS X11, X9, X11             // c441305ddb
+       //TODO: VMINPS (BX), Y15, Y2            // c4e1045d13 or c5845d13
+       //TODO: VMINPS (R11), Y15, Y2           // c4c1045d13
+       //TODO: VMINPS Y2, Y15, Y2              // c4e1045dd2 or c5845dd2
+       //TODO: VMINPS Y11, Y15, Y2             // c4c1045dd3
+       //TODO: VMINPS (BX), Y15, Y11           // c461045d1b or c5045d1b
+       //TODO: VMINPS (R11), Y15, Y11          // c441045d1b
+       //TODO: VMINPS Y2, Y15, Y11             // c461045dda or c5045dda
+       //TODO: VMINPS Y11, Y15, Y11            // c441045ddb
+       //TODO: VMINSD (BX), X9, X2             // c4e1335d13 or c5b35d13
+       //TODO: VMINSD (R11), X9, X2            // c4c1335d13
+       //TODO: VMINSD X2, X9, X2               // c4e1335dd2 or c5b35dd2
+       //TODO: VMINSD X11, X9, X2              // c4c1335dd3
+       //TODO: VMINSD (BX), X9, X11            // c461335d1b or c5335d1b
+       //TODO: VMINSD (R11), X9, X11           // c441335d1b
+       //TODO: VMINSD X2, X9, X11              // c461335dda or c5335dda
+       //TODO: VMINSD X11, X9, X11             // c441335ddb
+       //TODO: VMINSS (BX), X9, X2             // c4e1325d13 or c5b25d13
+       //TODO: VMINSS (R11), X9, X2            // c4c1325d13
+       //TODO: VMINSS X2, X9, X2               // c4e1325dd2 or c5b25dd2
+       //TODO: VMINSS X11, X9, X2              // c4c1325dd3
+       //TODO: VMINSS (BX), X9, X11            // c461325d1b or c5325d1b
+       //TODO: VMINSS (R11), X9, X11           // c441325d1b
+       //TODO: VMINSS X2, X9, X11              // c461325dda or c5325dda
+       //TODO: VMINSS X11, X9, X11             // c441325ddb
+       //TODO: VMOVAPD (BX), X2                // c4e1792813 or c5f92813
+       //TODO: VMOVAPD (R11), X2               // c4c1792813
+       //TODO: VMOVAPD X2, X2                  // c4e17928d2 or c5f928d2 or c4e17929d2 or c5f929d2
+       //TODO: VMOVAPD X11, X2                 // c4c17928d3 or c4617929da or c57929da
+       //TODO: VMOVAPD (BX), X11               // c46179281b or c579281b
+       //TODO: VMOVAPD (R11), X11              // c44179281b
+       //TODO: VMOVAPD X2, X11                 // c4617928da or c57928da or c4c17929d3
+       //TODO: VMOVAPD X11, X11                // c4417928db or c4417929db
+       //TODO: VMOVAPD X2, (BX)                // c4e1792913 or c5f92913
+       //TODO: VMOVAPD X11, (BX)               // c46179291b or c579291b
+       //TODO: VMOVAPD X2, (R11)               // c4c1792913
+       //TODO: VMOVAPD X11, (R11)              // c44179291b
+       //TODO: VMOVAPD (BX), Y2                // c4e17d2813 or c5fd2813
+       //TODO: VMOVAPD (R11), Y2               // c4c17d2813
+       //TODO: VMOVAPD Y2, Y2                  // c4e17d28d2 or c5fd28d2 or c4e17d29d2 or c5fd29d2
+       //TODO: VMOVAPD Y11, Y2                 // c4c17d28d3 or c4617d29da or c57d29da
+       //TODO: VMOVAPD (BX), Y11               // c4617d281b or c57d281b
+       //TODO: VMOVAPD (R11), Y11              // c4417d281b
+       //TODO: VMOVAPD Y2, Y11                 // c4617d28da or c57d28da or c4c17d29d3
+       //TODO: VMOVAPD Y11, Y11                // c4417d28db or c4417d29db
+       //TODO: VMOVAPD Y2, (BX)                // c4e17d2913 or c5fd2913
+       //TODO: VMOVAPD Y11, (BX)               // c4617d291b or c57d291b
+       //TODO: VMOVAPD Y2, (R11)               // c4c17d2913
+       //TODO: VMOVAPD Y11, (R11)              // c4417d291b
+       //TODO: VMOVAPS (BX), X2                // c4e1782813 or c5f82813
+       //TODO: VMOVAPS (R11), X2               // c4c1782813
+       //TODO: VMOVAPS X2, X2                  // c4e17828d2 or c5f828d2 or c4e17829d2 or c5f829d2
+       //TODO: VMOVAPS X11, X2                 // c4c17828d3 or c4617829da or c57829da
+       //TODO: VMOVAPS (BX), X11               // c46178281b or c578281b
+       //TODO: VMOVAPS (R11), X11              // c44178281b
+       //TODO: VMOVAPS X2, X11                 // c4617828da or c57828da or c4c17829d3
+       //TODO: VMOVAPS X11, X11                // c4417828db or c4417829db
+       //TODO: VMOVAPS X2, (BX)                // c4e1782913 or c5f82913
+       //TODO: VMOVAPS X11, (BX)               // c46178291b or c578291b
+       //TODO: VMOVAPS X2, (R11)               // c4c1782913
+       //TODO: VMOVAPS X11, (R11)              // c44178291b
+       //TODO: VMOVAPS (BX), Y2                // c4e17c2813 or c5fc2813
+       //TODO: VMOVAPS (R11), Y2               // c4c17c2813
+       //TODO: VMOVAPS Y2, Y2                  // c4e17c28d2 or c5fc28d2 or c4e17c29d2 or c5fc29d2
+       //TODO: VMOVAPS Y11, Y2                 // c4c17c28d3 or c4617c29da or c57c29da
+       //TODO: VMOVAPS (BX), Y11               // c4617c281b or c57c281b
+       //TODO: VMOVAPS (R11), Y11              // c4417c281b
+       //TODO: VMOVAPS Y2, Y11                 // c4617c28da or c57c28da or c4c17c29d3
+       //TODO: VMOVAPS Y11, Y11                // c4417c28db or c4417c29db
+       //TODO: VMOVAPS Y2, (BX)                // c4e17c2913 or c5fc2913
+       //TODO: VMOVAPS Y11, (BX)               // c4617c291b or c57c291b
+       //TODO: VMOVAPS Y2, (R11)               // c4c17c2913
+       //TODO: VMOVAPS Y11, (R11)              // c4417c291b
+       //TODO: VMOVD X2, (BX)                  // c4e1797e13 or c5f97e13
+       //TODO: VMOVD X11, (BX)                 // c461797e1b or c5797e1b
+       //TODO: VMOVD X2, (R11)                 // c4c1797e13
+       //TODO: VMOVD X11, (R11)                // c441797e1b
+       //TODO: VMOVD X2, DX                    // c4e1797ed2 or c5f97ed2
+       //TODO: VMOVD X11, DX                   // c461797eda or c5797eda
+       //TODO: VMOVD X2, R11                   // c4c1797ed3
+       //TODO: VMOVD X11, R11                  // c441797edb
+       //TODO: VMOVD (BX), X2                  // c4e1796e13 or c5f96e13
+       //TODO: VMOVD (R11), X2                 // c4c1796e13
+       //TODO: VMOVD DX, X2                    // c4e1796ed2 or c5f96ed2
+       //TODO: VMOVD R11, X2                   // c4c1796ed3
+       //TODO: VMOVD (BX), X11                 // c461796e1b or c5796e1b
+       //TODO: VMOVD (R11), X11                // c441796e1b
+       //TODO: VMOVD DX, X11                   // c461796eda or c5796eda
+       //TODO: VMOVD R11, X11                  // c441796edb
+       //TODO: VMOVDDUP (BX), X2               // c4e17b1213 or c5fb1213
+       //TODO: VMOVDDUP (R11), X2              // c4c17b1213
+       //TODO: VMOVDDUP X2, X2                 // c4e17b12d2 or c5fb12d2
+       //TODO: VMOVDDUP X11, X2                // c4c17b12d3
+       //TODO: VMOVDDUP (BX), X11              // c4617b121b or c57b121b
+       //TODO: VMOVDDUP (R11), X11             // c4417b121b
+       //TODO: VMOVDDUP X2, X11                // c4617b12da or c57b12da
+       //TODO: VMOVDDUP X11, X11               // c4417b12db
+       //TODO: VMOVDDUP (BX), Y2               // c4e17f1213 or c5ff1213
+       //TODO: VMOVDDUP (R11), Y2              // c4c17f1213
+       //TODO: VMOVDDUP Y2, Y2                 // c4e17f12d2 or c5ff12d2
+       //TODO: VMOVDDUP Y11, Y2                // c4c17f12d3
+       //TODO: VMOVDDUP (BX), Y11              // c4617f121b or c57f121b
+       //TODO: VMOVDDUP (R11), Y11             // c4417f121b
+       //TODO: VMOVDDUP Y2, Y11                // c4617f12da or c57f12da
+       //TODO: VMOVDDUP Y11, Y11               // c4417f12db
+       VMOVDQA (BX), X2                        // c4e1796f13 or c5f96f13
+       VMOVDQA (R11), X2                       // c4c1796f13
+       VMOVDQA X2, X2                          // c4e1796fd2 or c5f96fd2 or c4e1797fd2 or c5f97fd2
+       VMOVDQA X11, X2                         // c4c1796fd3 or c461797fda or c5797fda
+       VMOVDQA (BX), X11                       // c461796f1b or c5796f1b
+       VMOVDQA (R11), X11                      // c441796f1b
+       VMOVDQA X2, X11                         // c461796fda or c5796fda or c4c1797fd3
+       VMOVDQA X11, X11                        // c441796fdb or c441797fdb
+       VMOVDQA X2, (BX)                        // c4e1797f13 or c5f97f13
+       VMOVDQA X11, (BX)                       // c461797f1b or c5797f1b
+       VMOVDQA X2, (R11)                       // c4c1797f13
+       VMOVDQA X11, (R11)                      // c441797f1b
+       VMOVDQA (BX), Y2                        // c4e17d6f13 or c5fd6f13
+       VMOVDQA (R11), Y2                       // c4c17d6f13
+       VMOVDQA Y2, Y2                          // c4e17d6fd2 or c5fd6fd2 or c4e17d7fd2 or c5fd7fd2
+       VMOVDQA Y11, Y2                         // c4c17d6fd3 or c4617d7fda or c57d7fda
+       VMOVDQA (BX), Y11                       // c4617d6f1b or c57d6f1b
+       VMOVDQA (R11), Y11                      // c4417d6f1b
+       VMOVDQA Y2, Y11                         // c4617d6fda or c57d6fda or c4c17d7fd3
+       VMOVDQA Y11, Y11                        // c4417d6fdb or c4417d7fdb
+       VMOVDQA Y2, (BX)                        // c4e17d7f13 or c5fd7f13
+       VMOVDQA Y11, (BX)                       // c4617d7f1b or c57d7f1b
+       VMOVDQA Y2, (R11)                       // c4c17d7f13
+       VMOVDQA Y11, (R11)                      // c4417d7f1b
+       VMOVDQU (BX), X2                        // c4e17a6f13 or c5fa6f13
+       VMOVDQU (R11), X2                       // c4c17a6f13
+       VMOVDQU X2, X2                          // c4e17a6fd2 or c5fa6fd2 or c4e17a7fd2 or c5fa7fd2
+       VMOVDQU X11, X2                         // c4c17a6fd3 or c4617a7fda or c57a7fda
+       VMOVDQU (BX), X11                       // c4617a6f1b or c57a6f1b
+       VMOVDQU (R11), X11                      // c4417a6f1b
+       VMOVDQU X2, X11                         // c4617a6fda or c57a6fda or c4c17a7fd3
+       VMOVDQU X11, X11                        // c4417a6fdb or c4417a7fdb
+       VMOVDQU X2, (BX)                        // c4e17a7f13 or c5fa7f13
+       VMOVDQU X11, (BX)                       // c4617a7f1b or c57a7f1b
+       VMOVDQU X2, (R11)                       // c4c17a7f13
+       VMOVDQU X11, (R11)                      // c4417a7f1b
+       VMOVDQU (BX), Y2                        // c4e17e6f13 or c5fe6f13
+       VMOVDQU (R11), Y2                       // c4c17e6f13
+       VMOVDQU Y2, Y2                          // c4e17e6fd2 or c5fe6fd2 or c4e17e7fd2 or c5fe7fd2
+       VMOVDQU Y11, Y2                         // c4c17e6fd3 or c4617e7fda or c57e7fda
+       VMOVDQU (BX), Y11                       // c4617e6f1b or c57e6f1b
+       VMOVDQU (R11), Y11                      // c4417e6f1b
+       VMOVDQU Y2, Y11                         // c4617e6fda or c57e6fda or c4c17e7fd3
+       VMOVDQU Y11, Y11                        // c4417e6fdb or c4417e7fdb
+       VMOVDQU Y2, (BX)                        // c4e17e7f13 or c5fe7f13
+       VMOVDQU Y11, (BX)                       // c4617e7f1b or c57e7f1b
+       VMOVDQU Y2, (R11)                       // c4c17e7f13
+       VMOVDQU Y11, (R11)                      // c4417e7f1b
+       //TODO: VMOVHLPS X2, X9, X2             // c4e13012d2 or c5b012d2
+       //TODO: VMOVHLPS X11, X9, X2            // c4c13012d3
+       //TODO: VMOVHLPS X2, X9, X11            // c4613012da or c53012da
+       //TODO: VMOVHLPS X11, X9, X11           // c4413012db
+       //TODO: VMOVHPD X2, (BX)                // c4e1791713 or c5f91713
+       //TODO: VMOVHPD X11, (BX)               // c46179171b or c579171b
+       //TODO: VMOVHPD X2, (R11)               // c4c1791713
+       //TODO: VMOVHPD X11, (R11)              // c44179171b
+       //TODO: VMOVHPD (BX), X9, X2            // c4e1311613 or c5b11613
+       //TODO: VMOVHPD (R11), X9, X2           // c4c1311613
+       //TODO: VMOVHPD (BX), X9, X11           // c46131161b or c531161b
+       //TODO: VMOVHPD (R11), X9, X11          // c44131161b
+       //TODO: VMOVHPS X2, (BX)                // c4e1781713 or c5f81713
+       //TODO: VMOVHPS X11, (BX)               // c46178171b or c578171b
+       //TODO: VMOVHPS X2, (R11)               // c4c1781713
+       //TODO: VMOVHPS X11, (R11)              // c44178171b
+       //TODO: VMOVHPS (BX), X9, X2            // c4e1301613 or c5b01613
+       //TODO: VMOVHPS (R11), X9, X2           // c4c1301613
+       //TODO: VMOVHPS (BX), X9, X11           // c46130161b or c530161b
+       //TODO: VMOVHPS (R11), X9, X11          // c44130161b
+       //TODO: VMOVLHPS X2, X9, X2             // c4e13016d2 or c5b016d2
+       //TODO: VMOVLHPS X11, X9, X2            // c4c13016d3
+       //TODO: VMOVLHPS X2, X9, X11            // c4613016da or c53016da
+       //TODO: VMOVLHPS X11, X9, X11           // c4413016db
+       //TODO: VMOVLPD X2, (BX)                // c4e1791313 or c5f91313
+       //TODO: VMOVLPD X11, (BX)               // c46179131b or c579131b
+       //TODO: VMOVLPD X2, (R11)               // c4c1791313
+       //TODO: VMOVLPD X11, (R11)              // c44179131b
+       //TODO: VMOVLPD (BX), X9, X2            // c4e1311213 or c5b11213
+       //TODO: VMOVLPD (R11), X9, X2           // c4c1311213
+       //TODO: VMOVLPD (BX), X9, X11           // c46131121b or c531121b
+       //TODO: VMOVLPD (R11), X9, X11          // c44131121b
+       //TODO: VMOVLPS X2, (BX)                // c4e1781313 or c5f81313
+       //TODO: VMOVLPS X11, (BX)               // c46178131b or c578131b
+       //TODO: VMOVLPS X2, (R11)               // c4c1781313
+       //TODO: VMOVLPS X11, (R11)              // c44178131b
+       //TODO: VMOVLPS (BX), X9, X2            // c4e1301213 or c5b01213
+       //TODO: VMOVLPS (R11), X9, X2           // c4c1301213
+       //TODO: VMOVLPS (BX), X9, X11           // c46130121b or c530121b
+       //TODO: VMOVLPS (R11), X9, X11          // c44130121b
+       //TODO: VMOVMSKPD X2, DX                // c4e17950d2 or c5f950d2
+       //TODO: VMOVMSKPD X11, DX               // c4c17950d3
+       //TODO: VMOVMSKPD X2, R11               // c4617950da or c57950da
+       //TODO: VMOVMSKPD X11, R11              // c4417950db
+       //TODO: VMOVMSKPD Y2, DX                // c4e17d50d2 or c5fd50d2
+       //TODO: VMOVMSKPD Y11, DX               // c4c17d50d3
+       //TODO: VMOVMSKPD Y2, R11               // c4617d50da or c57d50da
+       //TODO: VMOVMSKPD Y11, R11              // c4417d50db
+       //TODO: VMOVMSKPS X2, DX                // c4e17850d2 or c5f850d2
+       //TODO: VMOVMSKPS X11, DX               // c4c17850d3
+       //TODO: VMOVMSKPS X2, R11               // c4617850da or c57850da
+       //TODO: VMOVMSKPS X11, R11              // c4417850db
+       //TODO: VMOVMSKPS Y2, DX                // c4e17c50d2 or c5fc50d2
+       //TODO: VMOVMSKPS Y11, DX               // c4c17c50d3
+       //TODO: VMOVMSKPS Y2, R11               // c4617c50da or c57c50da
+       //TODO: VMOVMSKPS Y11, R11              // c4417c50db
+       VMOVNTDQ X2, (BX)                       // c4e179e713 or c5f9e713
+       VMOVNTDQ X11, (BX)                      // c46179e71b or c579e71b
+       VMOVNTDQ X2, (R11)                      // c4c179e713
+       VMOVNTDQ X11, (R11)                     // c44179e71b
+       VMOVNTDQ Y2, (BX)                       // c4e17de713 or c5fde713
+       VMOVNTDQ Y11, (BX)                      // c4617de71b or c57de71b
+       VMOVNTDQ Y2, (R11)                      // c4c17de713
+       VMOVNTDQ Y11, (R11)                     // c4417de71b
+       //TODO: VMOVNTDQA (BX), X2              // c4e2792a13
+       //TODO: VMOVNTDQA (R11), X2             // c4c2792a13
+       //TODO: VMOVNTDQA (BX), X11             // c462792a1b
+       //TODO: VMOVNTDQA (R11), X11            // c442792a1b
+       //TODO: VMOVNTDQA (BX), Y2              // c4e27d2a13
+       //TODO: VMOVNTDQA (R11), Y2             // c4c27d2a13
+       //TODO: VMOVNTDQA (BX), Y11             // c4627d2a1b
+       //TODO: VMOVNTDQA (R11), Y11            // c4427d2a1b
+       //TODO: VMOVNTPD X2, (BX)               // c4e1792b13 or c5f92b13
+       //TODO: VMOVNTPD X11, (BX)              // c461792b1b or c5792b1b
+       //TODO: VMOVNTPD X2, (R11)              // c4c1792b13
+       //TODO: VMOVNTPD X11, (R11)             // c441792b1b
+       //TODO: VMOVNTPD Y2, (BX)               // c4e17d2b13 or c5fd2b13
+       //TODO: VMOVNTPD Y11, (BX)              // c4617d2b1b or c57d2b1b
+       //TODO: VMOVNTPD Y2, (R11)              // c4c17d2b13
+       //TODO: VMOVNTPD Y11, (R11)             // c4417d2b1b
+       //TODO: VMOVNTPS X2, (BX)               // c4e1782b13 or c5f82b13
+       //TODO: VMOVNTPS X11, (BX)              // c461782b1b or c5782b1b
+       //TODO: VMOVNTPS X2, (R11)              // c4c1782b13
+       //TODO: VMOVNTPS X11, (R11)             // c441782b1b
+       //TODO: VMOVNTPS Y2, (BX)               // c4e17c2b13 or c5fc2b13
+       //TODO: VMOVNTPS Y11, (BX)              // c4617c2b1b or c57c2b1b
+       //TODO: VMOVNTPS Y2, (R11)              // c4c17c2b13
+       //TODO: VMOVNTPS Y11, (R11)             // c4417c2b1b
+       //TODO: VMOVQ X2, (BX)                  // c4e1f97e13 or c4e179d613 or c5f9d613
+       //TODO: VMOVQ X11, (BX)                 // c461f97e1b or c46179d61b or c579d61b
+       //TODO: VMOVQ X2, (R11)                 // c4c1f97e13 or c4c179d613
+       //TODO: VMOVQ X11, (R11)                // c441f97e1b or c44179d61b
+       //TODO: VMOVQ X2, DX                    // c4e1f97ed2
+       //TODO: VMOVQ X11, DX                   // c461f97eda
+       //TODO: VMOVQ X2, R11                   // c4c1f97ed3
+       //TODO: VMOVQ X11, R11                  // c441f97edb
+       //TODO: VMOVQ (BX), X2                  // c4e17a7e13 or c5fa7e13 or c4e1f96e13
+       //TODO: VMOVQ (R11), X2                 // c4c17a7e13 or c4c1f96e13
+       //TODO: VMOVQ (BX), X11                 // c4617a7e1b or c57a7e1b or c461f96e1b
+       //TODO: VMOVQ (R11), X11                // c4417a7e1b or c441f96e1b
+       //TODO: VMOVQ DX, X2                    // c4e1f96ed2
+       //TODO: VMOVQ R11, X2                   // c4c1f96ed3
+       //TODO: VMOVQ DX, X11                   // c461f96eda
+       //TODO: VMOVQ R11, X11                  // c441f96edb
+       //TODO: VMOVQ X2, X2                    // c4e17a7ed2 or c5fa7ed2 or c4e179d6d2 or c5f9d6d2
+       //TODO: VMOVQ X11, X2                   // c4c17a7ed3 or c46179d6da or c579d6da
+       //TODO: VMOVQ X2, X11                   // c4617a7eda or c57a7eda or c4c179d6d3
+       //TODO: VMOVQ X11, X11                  // c4417a7edb or c44179d6db
+       //TODO: VMOVSD X2, (BX)                 // c4e17b1113 or c5fb1113
+       //TODO: VMOVSD X11, (BX)                // c4617b111b or c57b111b
+       //TODO: VMOVSD X2, (R11)                // c4c17b1113
+       //TODO: VMOVSD X11, (R11)               // c4417b111b
+       //TODO: VMOVSD (BX), X2                 // c4e17b1013 or c5fb1013
+       //TODO: VMOVSD (R11), X2                // c4c17b1013
+       //TODO: VMOVSD (BX), X11                // c4617b101b or c57b101b
+       //TODO: VMOVSD (R11), X11               // c4417b101b
+       //TODO: VMOVSD X2, X9, X2               // c4e13310d2 or c5b310d2 or c4e13311d2 or c5b311d2
+       //TODO: VMOVSD X11, X9, X2              // c4c13310d3 or c4613311da or c53311da
+       //TODO: VMOVSD X2, X9, X11              // c4613310da or c53310da or c4c13311d3
+       //TODO: VMOVSD X11, X9, X11             // c4413310db or c4413311db
+       //TODO: VMOVSHDUP (BX), X2              // c4e17a1613 or c5fa1613
+       //TODO: VMOVSHDUP (R11), X2             // c4c17a1613
+       //TODO: VMOVSHDUP X2, X2                // c4e17a16d2 or c5fa16d2
+       //TODO: VMOVSHDUP X11, X2               // c4c17a16d3
+       //TODO: VMOVSHDUP (BX), X11             // c4617a161b or c57a161b
+       //TODO: VMOVSHDUP (R11), X11            // c4417a161b
+       //TODO: VMOVSHDUP X2, X11               // c4617a16da or c57a16da
+       //TODO: VMOVSHDUP X11, X11              // c4417a16db
+       //TODO: VMOVSHDUP (BX), Y2              // c4e17e1613 or c5fe1613
+       //TODO: VMOVSHDUP (R11), Y2             // c4c17e1613
+       //TODO: VMOVSHDUP Y2, Y2                // c4e17e16d2 or c5fe16d2
+       //TODO: VMOVSHDUP Y11, Y2               // c4c17e16d3
+       //TODO: VMOVSHDUP (BX), Y11             // c4617e161b or c57e161b
+       //TODO: VMOVSHDUP (R11), Y11            // c4417e161b
+       //TODO: VMOVSHDUP Y2, Y11               // c4617e16da or c57e16da
+       //TODO: VMOVSHDUP Y11, Y11              // c4417e16db
+       //TODO: VMOVSLDUP (BX), X2              // c4e17a1213 or c5fa1213
+       //TODO: VMOVSLDUP (R11), X2             // c4c17a1213
+       //TODO: VMOVSLDUP X2, X2                // c4e17a12d2 or c5fa12d2
+       //TODO: VMOVSLDUP X11, X2               // c4c17a12d3
+       //TODO: VMOVSLDUP (BX), X11             // c4617a121b or c57a121b
+       //TODO: VMOVSLDUP (R11), X11            // c4417a121b
+       //TODO: VMOVSLDUP X2, X11               // c4617a12da or c57a12da
+       //TODO: VMOVSLDUP X11, X11              // c4417a12db
+       //TODO: VMOVSLDUP (BX), Y2              // c4e17e1213 or c5fe1213
+       //TODO: VMOVSLDUP (R11), Y2             // c4c17e1213
+       //TODO: VMOVSLDUP Y2, Y2                // c4e17e12d2 or c5fe12d2
+       //TODO: VMOVSLDUP Y11, Y2               // c4c17e12d3
+       //TODO: VMOVSLDUP (BX), Y11             // c4617e121b or c57e121b
+       //TODO: VMOVSLDUP (R11), Y11            // c4417e121b
+       //TODO: VMOVSLDUP Y2, Y11               // c4617e12da or c57e12da
+       //TODO: VMOVSLDUP Y11, Y11              // c4417e12db
+       //TODO: VMOVSS X2, (BX)                 // c4e17a1113 or c5fa1113
+       //TODO: VMOVSS X11, (BX)                // c4617a111b or c57a111b
+       //TODO: VMOVSS X2, (R11)                // c4c17a1113
+       //TODO: VMOVSS X11, (R11)               // c4417a111b
+       //TODO: VMOVSS (BX), X2                 // c4e17a1013 or c5fa1013
+       //TODO: VMOVSS (R11), X2                // c4c17a1013
+       //TODO: VMOVSS (BX), X11                // c4617a101b or c57a101b
+       //TODO: VMOVSS (R11), X11               // c4417a101b
+       //TODO: VMOVSS X2, X9, X2               // c4e13210d2 or c5b210d2 or c4e13211d2 or c5b211d2
+       //TODO: VMOVSS X11, X9, X2              // c4c13210d3 or c4613211da or c53211da
+       //TODO: VMOVSS X2, X9, X11              // c4613210da or c53210da or c4c13211d3
+       //TODO: VMOVSS X11, X9, X11             // c4413210db or c4413211db
+       //TODO: VMOVUPD (BX), X2                // c4e1791013 or c5f91013
+       //TODO: VMOVUPD (R11), X2               // c4c1791013
+       //TODO: VMOVUPD X2, X2                  // c4e17910d2 or c5f910d2 or c4e17911d2 or c5f911d2
+       //TODO: VMOVUPD X11, X2                 // c4c17910d3 or c4617911da or c57911da
+       //TODO: VMOVUPD (BX), X11               // c46179101b or c579101b
+       //TODO: VMOVUPD (R11), X11              // c44179101b
+       //TODO: VMOVUPD X2, X11                 // c4617910da or c57910da or c4c17911d3
+       //TODO: VMOVUPD X11, X11                // c4417910db or c4417911db
+       //TODO: VMOVUPD X2, (BX)                // c4e1791113 or c5f91113
+       //TODO: VMOVUPD X11, (BX)               // c46179111b or c579111b
+       //TODO: VMOVUPD X2, (R11)               // c4c1791113
+       //TODO: VMOVUPD X11, (R11)              // c44179111b
+       //TODO: VMOVUPD (BX), Y2                // c4e17d1013 or c5fd1013
+       //TODO: VMOVUPD (R11), Y2               // c4c17d1013
+       //TODO: VMOVUPD Y2, Y2                  // c4e17d10d2 or c5fd10d2 or c4e17d11d2 or c5fd11d2
+       //TODO: VMOVUPD Y11, Y2                 // c4c17d10d3 or c4617d11da or c57d11da
+       //TODO: VMOVUPD (BX), Y11               // c4617d101b or c57d101b
+       //TODO: VMOVUPD (R11), Y11              // c4417d101b
+       //TODO: VMOVUPD Y2, Y11                 // c4617d10da or c57d10da or c4c17d11d3
+       //TODO: VMOVUPD Y11, Y11                // c4417d10db or c4417d11db
+       //TODO: VMOVUPD Y2, (BX)                // c4e17d1113 or c5fd1113
+       //TODO: VMOVUPD Y11, (BX)               // c4617d111b or c57d111b
+       //TODO: VMOVUPD Y2, (R11)               // c4c17d1113
+       //TODO: VMOVUPD Y11, (R11)              // c4417d111b
+       //TODO: VMOVUPS (BX), X2                // c4e1781013 or c5f81013
+       //TODO: VMOVUPS (R11), X2               // c4c1781013
+       //TODO: VMOVUPS X2, X2                  // c4e17810d2 or c5f810d2 or c4e17811d2 or c5f811d2
+       //TODO: VMOVUPS X11, X2                 // c4c17810d3 or c4617811da or c57811da
+       //TODO: VMOVUPS (BX), X11               // c46178101b or c578101b
+       //TODO: VMOVUPS (R11), X11              // c44178101b
+       //TODO: VMOVUPS X2, X11                 // c4617810da or c57810da or c4c17811d3
+       //TODO: VMOVUPS X11, X11                // c4417810db or c4417811db
+       //TODO: VMOVUPS X2, (BX)                // c4e1781113 or c5f81113
+       //TODO: VMOVUPS X11, (BX)               // c46178111b or c578111b
+       //TODO: VMOVUPS X2, (R11)               // c4c1781113
+       //TODO: VMOVUPS X11, (R11)              // c44178111b
+       //TODO: VMOVUPS (BX), Y2                // c4e17c1013 or c5fc1013
+       //TODO: VMOVUPS (R11), Y2               // c4c17c1013
+       //TODO: VMOVUPS Y2, Y2                  // c4e17c10d2 or c5fc10d2 or c4e17c11d2 or c5fc11d2
+       //TODO: VMOVUPS Y11, Y2                 // c4c17c10d3 or c4617c11da or c57c11da
+       //TODO: VMOVUPS (BX), Y11               // c4617c101b or c57c101b
+       //TODO: VMOVUPS (R11), Y11              // c4417c101b
+       //TODO: VMOVUPS Y2, Y11                 // c4617c10da or c57c10da or c4c17c11d3
+       //TODO: VMOVUPS Y11, Y11                // c4417c10db or c4417c11db
+       //TODO: VMOVUPS Y2, (BX)                // c4e17c1113 or c5fc1113
+       //TODO: VMOVUPS Y11, (BX)               // c4617c111b or c57c111b
+       //TODO: VMOVUPS Y2, (R11)               // c4c17c1113
+       //TODO: VMOVUPS Y11, (R11)              // c4417c111b
+       //TODO: VMPSADBW $7, (BX), X9, X2       // c4e331421307
+       //TODO: VMPSADBW $7, (R11), X9, X2      // c4c331421307
+       //TODO: VMPSADBW $7, X2, X9, X2         // c4e33142d207
+       //TODO: VMPSADBW $7, X11, X9, X2        // c4c33142d307
+       //TODO: VMPSADBW $7, (BX), X9, X11      // c46331421b07
+       //TODO: VMPSADBW $7, (R11), X9, X11     // c44331421b07
+       //TODO: VMPSADBW $7, X2, X9, X11        // c4633142da07
+       //TODO: VMPSADBW $7, X11, X9, X11       // c4433142db07
+       //TODO: VMPSADBW $7, (BX), Y15, Y2      // c4e305421307
+       //TODO: VMPSADBW $7, (R11), Y15, Y2     // c4c305421307
+       //TODO: VMPSADBW $7, Y2, Y15, Y2        // c4e30542d207
+       //TODO: VMPSADBW $7, Y11, Y15, Y2       // c4c30542d307
+       //TODO: VMPSADBW $7, (BX), Y15, Y11     // c46305421b07
+       //TODO: VMPSADBW $7, (R11), Y15, Y11    // c44305421b07
+       //TODO: VMPSADBW $7, Y2, Y15, Y11       // c4630542da07
+       //TODO: VMPSADBW $7, Y11, Y15, Y11      // c4430542db07
+       //TODO: VMULPD (BX), X9, X2             // c4e1315913 or c5b15913
+       //TODO: VMULPD (R11), X9, X2            // c4c1315913
+       //TODO: VMULPD X2, X9, X2               // c4e13159d2 or c5b159d2
+       //TODO: VMULPD X11, X9, X2              // c4c13159d3
+       //TODO: VMULPD (BX), X9, X11            // c46131591b or c531591b
+       //TODO: VMULPD (R11), X9, X11           // c44131591b
+       //TODO: VMULPD X2, X9, X11              // c4613159da or c53159da
+       //TODO: VMULPD X11, X9, X11             // c4413159db
+       //TODO: VMULPD (BX), Y15, Y2            // c4e1055913 or c5855913
+       //TODO: VMULPD (R11), Y15, Y2           // c4c1055913
+       //TODO: VMULPD Y2, Y15, Y2              // c4e10559d2 or c58559d2
+       //TODO: VMULPD Y11, Y15, Y2             // c4c10559d3
+       //TODO: VMULPD (BX), Y15, Y11           // c46105591b or c505591b
+       //TODO: VMULPD (R11), Y15, Y11          // c44105591b
+       //TODO: VMULPD Y2, Y15, Y11             // c4610559da or c50559da
+       //TODO: VMULPD Y11, Y15, Y11            // c4410559db
+       //TODO: VMULPS (BX), X9, X2             // c4e1305913 or c5b05913
+       //TODO: VMULPS (R11), X9, X2            // c4c1305913
+       //TODO: VMULPS X2, X9, X2               // c4e13059d2 or c5b059d2
+       //TODO: VMULPS X11, X9, X2              // c4c13059d3
+       //TODO: VMULPS (BX), X9, X11            // c46130591b or c530591b
+       //TODO: VMULPS (R11), X9, X11           // c44130591b
+       //TODO: VMULPS X2, X9, X11              // c4613059da or c53059da
+       //TODO: VMULPS X11, X9, X11             // c4413059db
+       //TODO: VMULPS (BX), Y15, Y2            // c4e1045913 or c5845913
+       //TODO: VMULPS (R11), Y15, Y2           // c4c1045913
+       //TODO: VMULPS Y2, Y15, Y2              // c4e10459d2 or c58459d2
+       //TODO: VMULPS Y11, Y15, Y2             // c4c10459d3
+       //TODO: VMULPS (BX), Y15, Y11           // c46104591b or c504591b
+       //TODO: VMULPS (R11), Y15, Y11          // c44104591b
+       //TODO: VMULPS Y2, Y15, Y11             // c4610459da or c50459da
+       //TODO: VMULPS Y11, Y15, Y11            // c4410459db
+       //TODO: VMULSD (BX), X9, X2             // c4e1335913 or c5b35913
+       //TODO: VMULSD (R11), X9, X2            // c4c1335913
+       //TODO: VMULSD X2, X9, X2               // c4e13359d2 or c5b359d2
+       //TODO: VMULSD X11, X9, X2              // c4c13359d3
+       //TODO: VMULSD (BX), X9, X11            // c46133591b or c533591b
+       //TODO: VMULSD (R11), X9, X11           // c44133591b
+       //TODO: VMULSD X2, X9, X11              // c4613359da or c53359da
+       //TODO: VMULSD X11, X9, X11             // c4413359db
+       //TODO: VMULSS (BX), X9, X2             // c4e1325913 or c5b25913
+       //TODO: VMULSS (R11), X9, X2            // c4c1325913
+       //TODO: VMULSS X2, X9, X2               // c4e13259d2 or c5b259d2
+       //TODO: VMULSS X11, X9, X2              // c4c13259d3
+       //TODO: VMULSS (BX), X9, X11            // c46132591b or c532591b
+       //TODO: VMULSS (R11), X9, X11           // c44132591b
+       //TODO: VMULSS X2, X9, X11              // c4613259da or c53259da
+       //TODO: VMULSS X11, X9, X11             // c4413259db
+       //TODO: VORPD (BX), X9, X2              // c4e1315613 or c5b15613
+       //TODO: VORPD (R11), X9, X2             // c4c1315613
+       //TODO: VORPD X2, X9, X2                // c4e13156d2 or c5b156d2
+       //TODO: VORPD X11, X9, X2               // c4c13156d3
+       //TODO: VORPD (BX), X9, X11             // c46131561b or c531561b
+       //TODO: VORPD (R11), X9, X11            // c44131561b
+       //TODO: VORPD X2, X9, X11               // c4613156da or c53156da
+       //TODO: VORPD X11, X9, X11              // c4413156db
+       //TODO: VORPD (BX), Y15, Y2             // c4e1055613 or c5855613
+       //TODO: VORPD (R11), Y15, Y2            // c4c1055613
+       //TODO: VORPD Y2, Y15, Y2               // c4e10556d2 or c58556d2
+       //TODO: VORPD Y11, Y15, Y2              // c4c10556d3
+       //TODO: VORPD (BX), Y15, Y11            // c46105561b or c505561b
+       //TODO: VORPD (R11), Y15, Y11           // c44105561b
+       //TODO: VORPD Y2, Y15, Y11              // c4610556da or c50556da
+       //TODO: VORPD Y11, Y15, Y11             // c4410556db
+       //TODO: VORPS (BX), X9, X2              // c4e1305613 or c5b05613
+       //TODO: VORPS (R11), X9, X2             // c4c1305613
+       //TODO: VORPS X2, X9, X2                // c4e13056d2 or c5b056d2
+       //TODO: VORPS X11, X9, X2               // c4c13056d3
+       //TODO: VORPS (BX), X9, X11             // c46130561b or c530561b
+       //TODO: VORPS (R11), X9, X11            // c44130561b
+       //TODO: VORPS X2, X9, X11               // c4613056da or c53056da
+       //TODO: VORPS X11, X9, X11              // c4413056db
+       //TODO: VORPS (BX), Y15, Y2             // c4e1045613 or c5845613
+       //TODO: VORPS (R11), Y15, Y2            // c4c1045613
+       //TODO: VORPS Y2, Y15, Y2               // c4e10456d2 or c58456d2
+       //TODO: VORPS Y11, Y15, Y2              // c4c10456d3
+       //TODO: VORPS (BX), Y15, Y11            // c46104561b or c504561b
+       //TODO: VORPS (R11), Y15, Y11           // c44104561b
+       //TODO: VORPS Y2, Y15, Y11              // c4610456da or c50456da
+       //TODO: VORPS Y11, Y15, Y11             // c4410456db
+       //TODO: VPABSB (BX), X2                 // c4e2791c13
+       //TODO: VPABSB (R11), X2                // c4c2791c13
+       //TODO: VPABSB X2, X2                   // c4e2791cd2
+       //TODO: VPABSB X11, X2                  // c4c2791cd3
+       //TODO: VPABSB (BX), X11                // c462791c1b
+       //TODO: VPABSB (R11), X11               // c442791c1b
+       //TODO: VPABSB X2, X11                  // c462791cda
+       //TODO: VPABSB X11, X11                 // c442791cdb
+       //TODO: VPABSB (BX), Y2                 // c4e27d1c13
+       //TODO: VPABSB (R11), Y2                // c4c27d1c13
+       //TODO: VPABSB Y2, Y2                   // c4e27d1cd2
+       //TODO: VPABSB Y11, Y2                  // c4c27d1cd3
+       //TODO: VPABSB (BX), Y11                // c4627d1c1b
+       //TODO: VPABSB (R11), Y11               // c4427d1c1b
+       //TODO: VPABSB Y2, Y11                  // c4627d1cda
+       //TODO: VPABSB Y11, Y11                 // c4427d1cdb
+       //TODO: VPABSD (BX), X2                 // c4e2791e13
+       //TODO: VPABSD (R11), X2                // c4c2791e13
+       //TODO: VPABSD X2, X2                   // c4e2791ed2
+       //TODO: VPABSD X11, X2                  // c4c2791ed3
+       //TODO: VPABSD (BX), X11                // c462791e1b
+       //TODO: VPABSD (R11), X11               // c442791e1b
+       //TODO: VPABSD X2, X11                  // c462791eda
+       //TODO: VPABSD X11, X11                 // c442791edb
+       //TODO: VPABSD (BX), Y2                 // c4e27d1e13
+       //TODO: VPABSD (R11), Y2                // c4c27d1e13
+       //TODO: VPABSD Y2, Y2                   // c4e27d1ed2
+       //TODO: VPABSD Y11, Y2                  // c4c27d1ed3
+       //TODO: VPABSD (BX), Y11                // c4627d1e1b
+       //TODO: VPABSD (R11), Y11               // c4427d1e1b
+       //TODO: VPABSD Y2, Y11                  // c4627d1eda
+       //TODO: VPABSD Y11, Y11                 // c4427d1edb
+       //TODO: VPABSW (BX), X2                 // c4e2791d13
+       //TODO: VPABSW (R11), X2                // c4c2791d13
+       //TODO: VPABSW X2, X2                   // c4e2791dd2
+       //TODO: VPABSW X11, X2                  // c4c2791dd3
+       //TODO: VPABSW (BX), X11                // c462791d1b
+       //TODO: VPABSW (R11), X11               // c442791d1b
+       //TODO: VPABSW X2, X11                  // c462791dda
+       //TODO: VPABSW X11, X11                 // c442791ddb
+       //TODO: VPABSW (BX), Y2                 // c4e27d1d13
+       //TODO: VPABSW (R11), Y2                // c4c27d1d13
+       //TODO: VPABSW Y2, Y2                   // c4e27d1dd2
+       //TODO: VPABSW Y11, Y2                  // c4c27d1dd3
+       //TODO: VPABSW (BX), Y11                // c4627d1d1b
+       //TODO: VPABSW (R11), Y11               // c4427d1d1b
+       //TODO: VPABSW Y2, Y11                  // c4627d1dda
+       //TODO: VPABSW Y11, Y11                 // c4427d1ddb
+       //TODO: VPACKSSDW (BX), X9, X2          // c4e1316b13 or c5b16b13
+       //TODO: VPACKSSDW (R11), X9, X2         // c4c1316b13
+       //TODO: VPACKSSDW X2, X9, X2            // c4e1316bd2 or c5b16bd2
+       //TODO: VPACKSSDW X11, X9, X2           // c4c1316bd3
+       //TODO: VPACKSSDW (BX), X9, X11         // c461316b1b or c5316b1b
+       //TODO: VPACKSSDW (R11), X9, X11        // c441316b1b
+       //TODO: VPACKSSDW X2, X9, X11           // c461316bda or c5316bda
+       //TODO: VPACKSSDW X11, X9, X11          // c441316bdb
+       //TODO: VPACKSSDW (BX), Y15, Y2         // c4e1056b13 or c5856b13
+       //TODO: VPACKSSDW (R11), Y15, Y2        // c4c1056b13
+       //TODO: VPACKSSDW Y2, Y15, Y2           // c4e1056bd2 or c5856bd2
+       //TODO: VPACKSSDW Y11, Y15, Y2          // c4c1056bd3
+       //TODO: VPACKSSDW (BX), Y15, Y11        // c461056b1b or c5056b1b
+       //TODO: VPACKSSDW (R11), Y15, Y11       // c441056b1b
+       //TODO: VPACKSSDW Y2, Y15, Y11          // c461056bda or c5056bda
+       //TODO: VPACKSSDW Y11, Y15, Y11         // c441056bdb
+       //TODO: VPACKSSWB (BX), X9, X2          // c4e1316313 or c5b16313
+       //TODO: VPACKSSWB (R11), X9, X2         // c4c1316313
+       //TODO: VPACKSSWB X2, X9, X2            // c4e13163d2 or c5b163d2
+       //TODO: VPACKSSWB X11, X9, X2           // c4c13163d3
+       //TODO: VPACKSSWB (BX), X9, X11         // c46131631b or c531631b
+       //TODO: VPACKSSWB (R11), X9, X11        // c44131631b
+       //TODO: VPACKSSWB X2, X9, X11           // c4613163da or c53163da
+       //TODO: VPACKSSWB X11, X9, X11          // c4413163db
+       //TODO: VPACKSSWB (BX), Y15, Y2         // c4e1056313 or c5856313
+       //TODO: VPACKSSWB (R11), Y15, Y2        // c4c1056313
+       //TODO: VPACKSSWB Y2, Y15, Y2           // c4e10563d2 or c58563d2
+       //TODO: VPACKSSWB Y11, Y15, Y2          // c4c10563d3
+       //TODO: VPACKSSWB (BX), Y15, Y11        // c46105631b or c505631b
+       //TODO: VPACKSSWB (R11), Y15, Y11       // c44105631b
+       //TODO: VPACKSSWB Y2, Y15, Y11          // c4610563da or c50563da
+       //TODO: VPACKSSWB Y11, Y15, Y11         // c4410563db
+       //TODO: VPACKUSDW (BX), X9, X2          // c4e2312b13
+       //TODO: VPACKUSDW (R11), X9, X2         // c4c2312b13
+       //TODO: VPACKUSDW X2, X9, X2            // c4e2312bd2
+       //TODO: VPACKUSDW X11, X9, X2           // c4c2312bd3
+       //TODO: VPACKUSDW (BX), X9, X11         // c462312b1b
+       //TODO: VPACKUSDW (R11), X9, X11        // c442312b1b
+       //TODO: VPACKUSDW X2, X9, X11           // c462312bda
+       //TODO: VPACKUSDW X11, X9, X11          // c442312bdb
+       //TODO: VPACKUSDW (BX), Y15, Y2         // c4e2052b13
+       //TODO: VPACKUSDW (R11), Y15, Y2        // c4c2052b13
+       //TODO: VPACKUSDW Y2, Y15, Y2           // c4e2052bd2
+       //TODO: VPACKUSDW Y11, Y15, Y2          // c4c2052bd3
+       //TODO: VPACKUSDW (BX), Y15, Y11        // c462052b1b
+       //TODO: VPACKUSDW (R11), Y15, Y11       // c442052b1b
+       //TODO: VPACKUSDW Y2, Y15, Y11          // c462052bda
+       //TODO: VPACKUSDW Y11, Y15, Y11         // c442052bdb
+       //TODO: VPACKUSWB (BX), X9, X2          // c4e1316713 or c5b16713
+       //TODO: VPACKUSWB (R11), X9, X2         // c4c1316713
+       //TODO: VPACKUSWB X2, X9, X2            // c4e13167d2 or c5b167d2
+       //TODO: VPACKUSWB X11, X9, X2           // c4c13167d3
+       //TODO: VPACKUSWB (BX), X9, X11         // c46131671b or c531671b
+       //TODO: VPACKUSWB (R11), X9, X11        // c44131671b
+       //TODO: VPACKUSWB X2, X9, X11           // c4613167da or c53167da
+       //TODO: VPACKUSWB X11, X9, X11          // c4413167db
+       //TODO: VPACKUSWB (BX), Y15, Y2         // c4e1056713 or c5856713
+       //TODO: VPACKUSWB (R11), Y15, Y2        // c4c1056713
+       //TODO: VPACKUSWB Y2, Y15, Y2           // c4e10567d2 or c58567d2
+       //TODO: VPACKUSWB Y11, Y15, Y2          // c4c10567d3
+       //TODO: VPACKUSWB (BX), Y15, Y11        // c46105671b or c505671b
+       //TODO: VPACKUSWB (R11), Y15, Y11       // c44105671b
+       //TODO: VPACKUSWB Y2, Y15, Y11          // c4610567da or c50567da
+       //TODO: VPACKUSWB Y11, Y15, Y11         // c4410567db
+       //TODO: VPADDB (BX), X9, X2             // c4e131fc13 or c5b1fc13
+       //TODO: VPADDB (R11), X9, X2            // c4c131fc13
+       //TODO: VPADDB X2, X9, X2               // c4e131fcd2 or c5b1fcd2
+       //TODO: VPADDB X11, X9, X2              // c4c131fcd3
+       //TODO: VPADDB (BX), X9, X11            // c46131fc1b or c531fc1b
+       //TODO: VPADDB (R11), X9, X11           // c44131fc1b
+       //TODO: VPADDB X2, X9, X11              // c46131fcda or c531fcda
+       //TODO: VPADDB X11, X9, X11             // c44131fcdb
+       //TODO: VPADDB (BX), Y15, Y2            // c4e105fc13 or c585fc13
+       //TODO: VPADDB (R11), Y15, Y2           // c4c105fc13
+       //TODO: VPADDB Y2, Y15, Y2              // c4e105fcd2 or c585fcd2
+       //TODO: VPADDB Y11, Y15, Y2             // c4c105fcd3
+       //TODO: VPADDB (BX), Y15, Y11           // c46105fc1b or c505fc1b
+       //TODO: VPADDB (R11), Y15, Y11          // c44105fc1b
+       //TODO: VPADDB Y2, Y15, Y11             // c46105fcda or c505fcda
+       //TODO: VPADDB Y11, Y15, Y11            // c44105fcdb
+       //TODO: VPADDD (BX), X9, X2             // c4e131fe13 or c5b1fe13
+       //TODO: VPADDD (R11), X9, X2            // c4c131fe13
+       //TODO: VPADDD X2, X9, X2               // c4e131fed2 or c5b1fed2
+       //TODO: VPADDD X11, X9, X2              // c4c131fed3
+       //TODO: VPADDD (BX), X9, X11            // c46131fe1b or c531fe1b
+       //TODO: VPADDD (R11), X9, X11           // c44131fe1b
+       //TODO: VPADDD X2, X9, X11              // c46131feda or c531feda
+       //TODO: VPADDD X11, X9, X11             // c44131fedb
+       //TODO: VPADDD (BX), Y15, Y2            // c4e105fe13 or c585fe13
+       //TODO: VPADDD (R11), Y15, Y2           // c4c105fe13
+       //TODO: VPADDD Y2, Y15, Y2              // c4e105fed2 or c585fed2
+       //TODO: VPADDD Y11, Y15, Y2             // c4c105fed3
+       //TODO: VPADDD (BX), Y15, Y11           // c46105fe1b or c505fe1b
+       //TODO: VPADDD (R11), Y15, Y11          // c44105fe1b
+       //TODO: VPADDD Y2, Y15, Y11             // c46105feda or c505feda
+       //TODO: VPADDD Y11, Y15, Y11            // c44105fedb
+       //TODO: VPADDQ (BX), X9, X2             // c4e131d413 or c5b1d413
+       //TODO: VPADDQ (R11), X9, X2            // c4c131d413
+       //TODO: VPADDQ X2, X9, X2               // c4e131d4d2 or c5b1d4d2
+       //TODO: VPADDQ X11, X9, X2              // c4c131d4d3
+       //TODO: VPADDQ (BX), X9, X11            // c46131d41b or c531d41b
+       //TODO: VPADDQ (R11), X9, X11           // c44131d41b
+       //TODO: VPADDQ X2, X9, X11              // c46131d4da or c531d4da
+       //TODO: VPADDQ X11, X9, X11             // c44131d4db
+       //TODO: VPADDQ (BX), Y15, Y2            // c4e105d413 or c585d413
+       //TODO: VPADDQ (R11), Y15, Y2           // c4c105d413
+       //TODO: VPADDQ Y2, Y15, Y2              // c4e105d4d2 or c585d4d2
+       //TODO: VPADDQ Y11, Y15, Y2             // c4c105d4d3
+       //TODO: VPADDQ (BX), Y15, Y11           // c46105d41b or c505d41b
+       //TODO: VPADDQ (R11), Y15, Y11          // c44105d41b
+       //TODO: VPADDQ Y2, Y15, Y11             // c46105d4da or c505d4da
+       //TODO: VPADDQ Y11, Y15, Y11            // c44105d4db
+       //TODO: VPADDSB (BX), X9, X2            // c4e131ec13 or c5b1ec13
+       //TODO: VPADDSB (R11), X9, X2           // c4c131ec13
+       //TODO: VPADDSB X2, X9, X2              // c4e131ecd2 or c5b1ecd2
+       //TODO: VPADDSB X11, X9, X2             // c4c131ecd3
+       //TODO: VPADDSB (BX), X9, X11           // c46131ec1b or c531ec1b
+       //TODO: VPADDSB (R11), X9, X11          // c44131ec1b
+       //TODO: VPADDSB X2, X9, X11             // c46131ecda or c531ecda
+       //TODO: VPADDSB X11, X9, X11            // c44131ecdb
+       //TODO: VPADDSB (BX), Y15, Y2           // c4e105ec13 or c585ec13
+       //TODO: VPADDSB (R11), Y15, Y2          // c4c105ec13
+       //TODO: VPADDSB Y2, Y15, Y2             // c4e105ecd2 or c585ecd2
+       //TODO: VPADDSB Y11, Y15, Y2            // c4c105ecd3
+       //TODO: VPADDSB (BX), Y15, Y11          // c46105ec1b or c505ec1b
+       //TODO: VPADDSB (R11), Y15, Y11         // c44105ec1b
+       //TODO: VPADDSB Y2, Y15, Y11            // c46105ecda or c505ecda
+       //TODO: VPADDSB Y11, Y15, Y11           // c44105ecdb
+       //TODO: VPADDSW (BX), X9, X2            // c4e131ed13 or c5b1ed13
+       //TODO: VPADDSW (R11), X9, X2           // c4c131ed13
+       //TODO: VPADDSW X2, X9, X2              // c4e131edd2 or c5b1edd2
+       //TODO: VPADDSW X11, X9, X2             // c4c131edd3
+       //TODO: VPADDSW (BX), X9, X11           // c46131ed1b or c531ed1b
+       //TODO: VPADDSW (R11), X9, X11          // c44131ed1b
+       //TODO: VPADDSW X2, X9, X11             // c46131edda or c531edda
+       //TODO: VPADDSW X11, X9, X11            // c44131eddb
+       //TODO: VPADDSW (BX), Y15, Y2           // c4e105ed13 or c585ed13
+       //TODO: VPADDSW (R11), Y15, Y2          // c4c105ed13
+       //TODO: VPADDSW Y2, Y15, Y2             // c4e105edd2 or c585edd2
+       //TODO: VPADDSW Y11, Y15, Y2            // c4c105edd3
+       //TODO: VPADDSW (BX), Y15, Y11          // c46105ed1b or c505ed1b
+       //TODO: VPADDSW (R11), Y15, Y11         // c44105ed1b
+       //TODO: VPADDSW Y2, Y15, Y11            // c46105edda or c505edda
+       //TODO: VPADDSW Y11, Y15, Y11           // c44105eddb
+       //TODO: VPADDUSB (BX), X9, X2           // c4e131dc13 or c5b1dc13
+       //TODO: VPADDUSB (R11), X9, X2          // c4c131dc13
+       //TODO: VPADDUSB X2, X9, X2             // c4e131dcd2 or c5b1dcd2
+       //TODO: VPADDUSB X11, X9, X2            // c4c131dcd3
+       //TODO: VPADDUSB (BX), X9, X11          // c46131dc1b or c531dc1b
+       //TODO: VPADDUSB (R11), X9, X11         // c44131dc1b
+       //TODO: VPADDUSB X2, X9, X11            // c46131dcda or c531dcda
+       //TODO: VPADDUSB X11, X9, X11           // c44131dcdb
+       //TODO: VPADDUSB (BX), Y15, Y2          // c4e105dc13 or c585dc13
+       //TODO: VPADDUSB (R11), Y15, Y2         // c4c105dc13
+       //TODO: VPADDUSB Y2, Y15, Y2            // c4e105dcd2 or c585dcd2
+       //TODO: VPADDUSB Y11, Y15, Y2           // c4c105dcd3
+       //TODO: VPADDUSB (BX), Y15, Y11         // c46105dc1b or c505dc1b
+       //TODO: VPADDUSB (R11), Y15, Y11        // c44105dc1b
+       //TODO: VPADDUSB Y2, Y15, Y11           // c46105dcda or c505dcda
+       //TODO: VPADDUSB Y11, Y15, Y11          // c44105dcdb
+       //TODO: VPADDUSW (BX), X9, X2           // c4e131dd13 or c5b1dd13
+       //TODO: VPADDUSW (R11), X9, X2          // c4c131dd13
+       //TODO: VPADDUSW X2, X9, X2             // c4e131ddd2 or c5b1ddd2
+       //TODO: VPADDUSW X11, X9, X2            // c4c131ddd3
+       //TODO: VPADDUSW (BX), X9, X11          // c46131dd1b or c531dd1b
+       //TODO: VPADDUSW (R11), X9, X11         // c44131dd1b
+       //TODO: VPADDUSW X2, X9, X11            // c46131ddda or c531ddda
+       //TODO: VPADDUSW X11, X9, X11           // c44131dddb
+       //TODO: VPADDUSW (BX), Y15, Y2          // c4e105dd13 or c585dd13
+       //TODO: VPADDUSW (R11), Y15, Y2         // c4c105dd13
+       //TODO: VPADDUSW Y2, Y15, Y2            // c4e105ddd2 or c585ddd2
+       //TODO: VPADDUSW Y11, Y15, Y2           // c4c105ddd3
+       //TODO: VPADDUSW (BX), Y15, Y11         // c46105dd1b or c505dd1b
+       //TODO: VPADDUSW (R11), Y15, Y11        // c44105dd1b
+       //TODO: VPADDUSW Y2, Y15, Y11           // c46105ddda or c505ddda
+       //TODO: VPADDUSW Y11, Y15, Y11          // c44105dddb
+       //TODO: VPADDW (BX), X9, X2             // c4e131fd13 or c5b1fd13
+       //TODO: VPADDW (R11), X9, X2            // c4c131fd13
+       //TODO: VPADDW X2, X9, X2               // c4e131fdd2 or c5b1fdd2
+       //TODO: VPADDW X11, X9, X2              // c4c131fdd3
+       //TODO: VPADDW (BX), X9, X11            // c46131fd1b or c531fd1b
+       //TODO: VPADDW (R11), X9, X11           // c44131fd1b
+       //TODO: VPADDW X2, X9, X11              // c46131fdda or c531fdda
+       //TODO: VPADDW X11, X9, X11             // c44131fddb
+       //TODO: VPADDW (BX), Y15, Y2            // c4e105fd13 or c585fd13
+       //TODO: VPADDW (R11), Y15, Y2           // c4c105fd13
+       //TODO: VPADDW Y2, Y15, Y2              // c4e105fdd2 or c585fdd2
+       //TODO: VPADDW Y11, Y15, Y2             // c4c105fdd3
+       //TODO: VPADDW (BX), Y15, Y11           // c46105fd1b or c505fd1b
+       //TODO: VPADDW (R11), Y15, Y11          // c44105fd1b
+       //TODO: VPADDW Y2, Y15, Y11             // c46105fdda or c505fdda
+       //TODO: VPADDW Y11, Y15, Y11            // c44105fddb
+       //TODO: VPALIGNR $7, (BX), X9, X2       // c4e3310f1307
+       //TODO: VPALIGNR $7, (R11), X9, X2      // c4c3310f1307
+       //TODO: VPALIGNR $7, X2, X9, X2         // c4e3310fd207
+       //TODO: VPALIGNR $7, X11, X9, X2        // c4c3310fd307
+       //TODO: VPALIGNR $7, (BX), X9, X11      // c463310f1b07
+       //TODO: VPALIGNR $7, (R11), X9, X11     // c443310f1b07
+       //TODO: VPALIGNR $7, X2, X9, X11        // c463310fda07
+       //TODO: VPALIGNR $7, X11, X9, X11       // c443310fdb07
+       //TODO: VPALIGNR $7, (BX), Y15, Y2      // c4e3050f1307
+       //TODO: VPALIGNR $7, (R11), Y15, Y2     // c4c3050f1307
+       //TODO: VPALIGNR $7, Y2, Y15, Y2        // c4e3050fd207
+       //TODO: VPALIGNR $7, Y11, Y15, Y2       // c4c3050fd307
+       //TODO: VPALIGNR $7, (BX), Y15, Y11     // c463050f1b07
+       //TODO: VPALIGNR $7, (R11), Y15, Y11    // c443050f1b07
+       //TODO: VPALIGNR $7, Y2, Y15, Y11       // c463050fda07
+       //TODO: VPALIGNR $7, Y11, Y15, Y11      // c443050fdb07
+       VPAND (BX), X9, X2                      // c4e131db13 or c5b1db13
+       VPAND (R11), X9, X2                     // c4c131db13
+       VPAND X2, X9, X2                        // c4e131dbd2 or c5b1dbd2
+       VPAND X11, X9, X2                       // c4c131dbd3
+       VPAND (BX), X9, X11                     // c46131db1b or c531db1b
+       VPAND (R11), X9, X11                    // c44131db1b
+       VPAND X2, X9, X11                       // c46131dbda or c531dbda
+       VPAND X11, X9, X11                      // c44131dbdb
+       VPAND (BX), Y15, Y2                     // c4e105db13 or c585db13
+       VPAND (R11), Y15, Y2                    // c4c105db13
+       VPAND Y2, Y15, Y2                       // c4e105dbd2 or c585dbd2
+       VPAND Y11, Y15, Y2                      // c4c105dbd3
+       VPAND (BX), Y15, Y11                    // c46105db1b or c505db1b
+       VPAND (R11), Y15, Y11                   // c44105db1b
+       VPAND Y2, Y15, Y11                      // c46105dbda or c505dbda
+       VPAND Y11, Y15, Y11                     // c44105dbdb
+       //TODO: VPANDN (BX), X9, X2             // c4e131df13 or c5b1df13
+       //TODO: VPANDN (R11), X9, X2            // c4c131df13
+       //TODO: VPANDN X2, X9, X2               // c4e131dfd2 or c5b1dfd2
+       //TODO: VPANDN X11, X9, X2              // c4c131dfd3
+       //TODO: VPANDN (BX), X9, X11            // c46131df1b or c531df1b
+       //TODO: VPANDN (R11), X9, X11           // c44131df1b
+       //TODO: VPANDN X2, X9, X11              // c46131dfda or c531dfda
+       //TODO: VPANDN X11, X9, X11             // c44131dfdb
+       //TODO: VPANDN (BX), Y15, Y2            // c4e105df13 or c585df13
+       //TODO: VPANDN (R11), Y15, Y2           // c4c105df13
+       //TODO: VPANDN Y2, Y15, Y2              // c4e105dfd2 or c585dfd2
+       //TODO: VPANDN Y11, Y15, Y2             // c4c105dfd3
+       //TODO: VPANDN (BX), Y15, Y11           // c46105df1b or c505df1b
+       //TODO: VPANDN (R11), Y15, Y11          // c44105df1b
+       //TODO: VPANDN Y2, Y15, Y11             // c46105dfda or c505dfda
+       //TODO: VPANDN Y11, Y15, Y11            // c44105dfdb
+       //TODO: VPAVGB (BX), X9, X2             // c4e131e013 or c5b1e013
+       //TODO: VPAVGB (R11), X9, X2            // c4c131e013
+       //TODO: VPAVGB X2, X9, X2               // c4e131e0d2 or c5b1e0d2
+       //TODO: VPAVGB X11, X9, X2              // c4c131e0d3
+       //TODO: VPAVGB (BX), X9, X11            // c46131e01b or c531e01b
+       //TODO: VPAVGB (R11), X9, X11           // c44131e01b
+       //TODO: VPAVGB X2, X9, X11              // c46131e0da or c531e0da
+       //TODO: VPAVGB X11, X9, X11             // c44131e0db
+       //TODO: VPAVGB (BX), Y15, Y2            // c4e105e013 or c585e013
+       //TODO: VPAVGB (R11), Y15, Y2           // c4c105e013
+       //TODO: VPAVGB Y2, Y15, Y2              // c4e105e0d2 or c585e0d2
+       //TODO: VPAVGB Y11, Y15, Y2             // c4c105e0d3
+       //TODO: VPAVGB (BX), Y15, Y11           // c46105e01b or c505e01b
+       //TODO: VPAVGB (R11), Y15, Y11          // c44105e01b
+       //TODO: VPAVGB Y2, Y15, Y11             // c46105e0da or c505e0da
+       //TODO: VPAVGB Y11, Y15, Y11            // c44105e0db
+       //TODO: VPAVGW (BX), X9, X2             // c4e131e313 or c5b1e313
+       //TODO: VPAVGW (R11), X9, X2            // c4c131e313
+       //TODO: VPAVGW X2, X9, X2               // c4e131e3d2 or c5b1e3d2
+       //TODO: VPAVGW X11, X9, X2              // c4c131e3d3
+       //TODO: VPAVGW (BX), X9, X11            // c46131e31b or c531e31b
+       //TODO: VPAVGW (R11), X9, X11           // c44131e31b
+       //TODO: VPAVGW X2, X9, X11              // c46131e3da or c531e3da
+       //TODO: VPAVGW X11, X9, X11             // c44131e3db
+       //TODO: VPAVGW (BX), Y15, Y2            // c4e105e313 or c585e313
+       //TODO: VPAVGW (R11), Y15, Y2           // c4c105e313
+       //TODO: VPAVGW Y2, Y15, Y2              // c4e105e3d2 or c585e3d2
+       //TODO: VPAVGW Y11, Y15, Y2             // c4c105e3d3
+       //TODO: VPAVGW (BX), Y15, Y11           // c46105e31b or c505e31b
+       //TODO: VPAVGW (R11), Y15, Y11          // c44105e31b
+       //TODO: VPAVGW Y2, Y15, Y11             // c46105e3da or c505e3da
+       //TODO: VPAVGW Y11, Y15, Y11            // c44105e3db
+       //TODO: VPBLENDD $7, (BX), X9, X2       // c4e331021307
+       //TODO: VPBLENDD $7, (R11), X9, X2      // c4c331021307
+       //TODO: VPBLENDD $7, X2, X9, X2         // c4e33102d207
+       //TODO: VPBLENDD $7, X11, X9, X2        // c4c33102d307
+       //TODO: VPBLENDD $7, (BX), X9, X11      // c46331021b07
+       //TODO: VPBLENDD $7, (R11), X9, X11     // c44331021b07
+       //TODO: VPBLENDD $7, X2, X9, X11        // c4633102da07
+       //TODO: VPBLENDD $7, X11, X9, X11       // c4433102db07
+       //TODO: VPBLENDD $7, (BX), Y15, Y2      // c4e305021307
+       //TODO: VPBLENDD $7, (R11), Y15, Y2     // c4c305021307
+       //TODO: VPBLENDD $7, Y2, Y15, Y2        // c4e30502d207
+       //TODO: VPBLENDD $7, Y11, Y15, Y2       // c4c30502d307
+       //TODO: VPBLENDD $7, (BX), Y15, Y11     // c46305021b07
+       //TODO: VPBLENDD $7, (R11), Y15, Y11    // c44305021b07
+       //TODO: VPBLENDD $7, Y2, Y15, Y11       // c4630502da07
+       //TODO: VPBLENDD $7, Y11, Y15, Y11      // c4430502db07
+       //TODO: VPBLENDVB XMM12, (BX), X9, X2   // c4e3314c13c0
+       //TODO: VPBLENDVB XMM12, (R11), X9, X2  // c4c3314c13c0
+       //TODO: VPBLENDVB XMM12, X2, X9, X2     // c4e3314cd2c0
+       //TODO: VPBLENDVB XMM12, X11, X9, X2    // c4c3314cd3c0
+       //TODO: VPBLENDVB XMM12, (BX), X9, X11  // c463314c1bc0
+       //TODO: VPBLENDVB XMM12, (R11), X9, X11 // c443314c1bc0
+       //TODO: VPBLENDVB XMM12, X2, X9, X11    // c463314cdac0
+       //TODO: VPBLENDVB XMM12, X11, X9, X11   // c443314cdbc0
+       //TODO: VPBLENDVB YMM13, (BX), Y15, Y2  // c4e3054c13d0
+       //TODO: VPBLENDVB YMM13, (R11), Y15, Y2 // c4c3054c13d0
+       //TODO: VPBLENDVB YMM13, Y2, Y15, Y2    // c4e3054cd2d0
+       //TODO: VPBLENDVB YMM13, Y11, Y15, Y2   // c4c3054cd3d0
+       //TODO: VPBLENDVB YMM13, (BX), Y15, Y11 // c463054c1bd0
+       //TODO: VPBLENDVB YMM13, (R11), Y15, Y11 // c443054c1bd0
+       //TODO: VPBLENDVB YMM13, Y2, Y15, Y11   // c463054cdad0
+       //TODO: VPBLENDVB YMM13, Y11, Y15, Y11  // c443054cdbd0
+       //TODO: VPBLENDW $7, (BX), X9, X2       // c4e3310e1307
+       //TODO: VPBLENDW $7, (R11), X9, X2      // c4c3310e1307
+       //TODO: VPBLENDW $7, X2, X9, X2         // c4e3310ed207
+       //TODO: VPBLENDW $7, X11, X9, X2        // c4c3310ed307
+       //TODO: VPBLENDW $7, (BX), X9, X11      // c463310e1b07
+       //TODO: VPBLENDW $7, (R11), X9, X11     // c443310e1b07
+       //TODO: VPBLENDW $7, X2, X9, X11        // c463310eda07
+       //TODO: VPBLENDW $7, X11, X9, X11       // c443310edb07
+       //TODO: VPBLENDW $7, (BX), Y15, Y2      // c4e3050e1307
+       //TODO: VPBLENDW $7, (R11), Y15, Y2     // c4c3050e1307
+       //TODO: VPBLENDW $7, Y2, Y15, Y2        // c4e3050ed207
+       //TODO: VPBLENDW $7, Y11, Y15, Y2       // c4c3050ed307
+       //TODO: VPBLENDW $7, (BX), Y15, Y11     // c463050e1b07
+       //TODO: VPBLENDW $7, (R11), Y15, Y11    // c443050e1b07
+       //TODO: VPBLENDW $7, Y2, Y15, Y11       // c463050eda07
+       //TODO: VPBLENDW $7, Y11, Y15, Y11      // c443050edb07
+       VPBROADCASTB (BX), X2                   // c4e2797813
+       VPBROADCASTB (R11), X2                  // c4c2797813
+       VPBROADCASTB X2, X2                     // c4e27978d2
+       VPBROADCASTB X11, X2                    // c4c27978d3
+       VPBROADCASTB (BX), X11                  // c46279781b
+       VPBROADCASTB (R11), X11                 // c44279781b
+       VPBROADCASTB X2, X11                    // c4627978da
+       VPBROADCASTB X11, X11                   // c4427978db
+       VPBROADCASTB (BX), Y2                   // c4e27d7813
+       VPBROADCASTB (R11), Y2                  // c4c27d7813
+       VPBROADCASTB X2, Y2                     // c4e27d78d2
+       VPBROADCASTB X11, Y2                    // c4c27d78d3
+       VPBROADCASTB (BX), Y11                  // c4627d781b
+       VPBROADCASTB (R11), Y11                 // c4427d781b
+       VPBROADCASTB X2, Y11                    // c4627d78da
+       VPBROADCASTB X11, Y11                   // c4427d78db
+       //TODO: VPBROADCASTD (BX), X2           // c4e2795813
+       //TODO: VPBROADCASTD (R11), X2          // c4c2795813
+       //TODO: VPBROADCASTD X2, X2             // c4e27958d2
+       //TODO: VPBROADCASTD X11, X2            // c4c27958d3
+       //TODO: VPBROADCASTD (BX), X11          // c46279581b
+       //TODO: VPBROADCASTD (R11), X11         // c44279581b
+       //TODO: VPBROADCASTD X2, X11            // c4627958da
+       //TODO: VPBROADCASTD X11, X11           // c4427958db
+       //TODO: VPBROADCASTD (BX), Y2           // c4e27d5813
+       //TODO: VPBROADCASTD (R11), Y2          // c4c27d5813
+       //TODO: VPBROADCASTD X2, Y2             // c4e27d58d2
+       //TODO: VPBROADCASTD X11, Y2            // c4c27d58d3
+       //TODO: VPBROADCASTD (BX), Y11          // c4627d581b
+       //TODO: VPBROADCASTD (R11), Y11         // c4427d581b
+       //TODO: VPBROADCASTD X2, Y11            // c4627d58da
+       //TODO: VPBROADCASTD X11, Y11           // c4427d58db
+       //TODO: VPBROADCASTQ (BX), X2           // c4e2795913
+       //TODO: VPBROADCASTQ (R11), X2          // c4c2795913
+       //TODO: VPBROADCASTQ X2, X2             // c4e27959d2
+       //TODO: VPBROADCASTQ X11, X2            // c4c27959d3
+       //TODO: VPBROADCASTQ (BX), X11          // c46279591b
+       //TODO: VPBROADCASTQ (R11), X11         // c44279591b
+       //TODO: VPBROADCASTQ X2, X11            // c4627959da
+       //TODO: VPBROADCASTQ X11, X11           // c4427959db
+       //TODO: VPBROADCASTQ (BX), Y2           // c4e27d5913
+       //TODO: VPBROADCASTQ (R11), Y2          // c4c27d5913
+       //TODO: VPBROADCASTQ X2, Y2             // c4e27d59d2
+       //TODO: VPBROADCASTQ X11, Y2            // c4c27d59d3
+       //TODO: VPBROADCASTQ (BX), Y11          // c4627d591b
+       //TODO: VPBROADCASTQ (R11), Y11         // c4427d591b
+       //TODO: VPBROADCASTQ X2, Y11            // c4627d59da
+       //TODO: VPBROADCASTQ X11, Y11           // c4427d59db
+       //TODO: VPBROADCASTW (BX), X2           // c4e2797913
+       //TODO: VPBROADCASTW (R11), X2          // c4c2797913
+       //TODO: VPBROADCASTW X2, X2             // c4e27979d2
+       //TODO: VPBROADCASTW X11, X2            // c4c27979d3
+       //TODO: VPBROADCASTW (BX), X11          // c46279791b
+       //TODO: VPBROADCASTW (R11), X11         // c44279791b
+       //TODO: VPBROADCASTW X2, X11            // c4627979da
+       //TODO: VPBROADCASTW X11, X11           // c4427979db
+       //TODO: VPBROADCASTW (BX), Y2           // c4e27d7913
+       //TODO: VPBROADCASTW (R11), Y2          // c4c27d7913
+       //TODO: VPBROADCASTW X2, Y2             // c4e27d79d2
+       //TODO: VPBROADCASTW X11, Y2            // c4c27d79d3
+       //TODO: VPBROADCASTW (BX), Y11          // c4627d791b
+       //TODO: VPBROADCASTW (R11), Y11         // c4427d791b
+       //TODO: VPBROADCASTW X2, Y11            // c4627d79da
+       //TODO: VPBROADCASTW X11, Y11           // c4427d79db
+       //TODO: VPCLMULQDQ $7, (BX), X9, X2     // c4e331441307
+       //TODO: VPCLMULQDQ $7, (R11), X9, X2    // c4c331441307
+       //TODO: VPCLMULQDQ $7, X2, X9, X2       // c4e33144d207
+       //TODO: VPCLMULQDQ $7, X11, X9, X2      // c4c33144d307
+       //TODO: VPCLMULQDQ $7, (BX), X9, X11    // c46331441b07
+       //TODO: VPCLMULQDQ $7, (R11), X9, X11   // c44331441b07
+       //TODO: VPCLMULQDQ $7, X2, X9, X11      // c4633144da07
+       //TODO: VPCLMULQDQ $7, X11, X9, X11     // c4433144db07
+       VPCMPEQB (BX), X9, X2                   // c4e1317413 or c5b17413
+       VPCMPEQB (R11), X9, X2                  // c4c1317413
+       VPCMPEQB X2, X9, X2                     // c4e13174d2 or c5b174d2
+       VPCMPEQB X11, X9, X2                    // c4c13174d3
+       VPCMPEQB (BX), X9, X11                  // c46131741b or c531741b
+       VPCMPEQB (R11), X9, X11                 // c44131741b
+       VPCMPEQB X2, X9, X11                    // c4613174da or c53174da
+       VPCMPEQB X11, X9, X11                   // c4413174db
+       VPCMPEQB (BX), Y15, Y2                  // c4e1057413 or c5857413
+       VPCMPEQB (R11), Y15, Y2                 // c4c1057413
+       VPCMPEQB Y2, Y15, Y2                    // c4e10574d2 or c58574d2
+       VPCMPEQB Y11, Y15, Y2                   // c4c10574d3
+       VPCMPEQB (BX), Y15, Y11                 // c46105741b or c505741b
+       VPCMPEQB (R11), Y15, Y11                // c44105741b
+       VPCMPEQB Y2, Y15, Y11                   // c4610574da or c50574da
+       VPCMPEQB Y11, Y15, Y11                  // c4410574db
+       //TODO: VPCMPEQD (BX), X9, X2           // c4e1317613 or c5b17613
+       //TODO: VPCMPEQD (R11), X9, X2          // c4c1317613
+       //TODO: VPCMPEQD X2, X9, X2             // c4e13176d2 or c5b176d2
+       //TODO: VPCMPEQD X11, X9, X2            // c4c13176d3
+       //TODO: VPCMPEQD (BX), X9, X11          // c46131761b or c531761b
+       //TODO: VPCMPEQD (R11), X9, X11         // c44131761b
+       //TODO: VPCMPEQD X2, X9, X11            // c4613176da or c53176da
+       //TODO: VPCMPEQD X11, X9, X11           // c4413176db
+       //TODO: VPCMPEQD (BX), Y15, Y2          // c4e1057613 or c5857613
+       //TODO: VPCMPEQD (R11), Y15, Y2         // c4c1057613
+       //TODO: VPCMPEQD Y2, Y15, Y2            // c4e10576d2 or c58576d2
+       //TODO: VPCMPEQD Y11, Y15, Y2           // c4c10576d3
+       //TODO: VPCMPEQD (BX), Y15, Y11         // c46105761b or c505761b
+       //TODO: VPCMPEQD (R11), Y15, Y11        // c44105761b
+       //TODO: VPCMPEQD Y2, Y15, Y11           // c4610576da or c50576da
+       //TODO: VPCMPEQD Y11, Y15, Y11          // c4410576db
+       //TODO: VPCMPEQQ (BX), X9, X2           // c4e2312913
+       //TODO: VPCMPEQQ (R11), X9, X2          // c4c2312913
+       //TODO: VPCMPEQQ X2, X9, X2             // c4e23129d2
+       //TODO: VPCMPEQQ X11, X9, X2            // c4c23129d3
+       //TODO: VPCMPEQQ (BX), X9, X11          // c46231291b
+       //TODO: VPCMPEQQ (R11), X9, X11         // c44231291b
+       //TODO: VPCMPEQQ X2, X9, X11            // c4623129da
+       //TODO: VPCMPEQQ X11, X9, X11           // c4423129db
+       //TODO: VPCMPEQQ (BX), Y15, Y2          // c4e2052913
+       //TODO: VPCMPEQQ (R11), Y15, Y2         // c4c2052913
+       //TODO: VPCMPEQQ Y2, Y15, Y2            // c4e20529d2
+       //TODO: VPCMPEQQ Y11, Y15, Y2           // c4c20529d3
+       //TODO: VPCMPEQQ (BX), Y15, Y11         // c46205291b
+       //TODO: VPCMPEQQ (R11), Y15, Y11        // c44205291b
+       //TODO: VPCMPEQQ Y2, Y15, Y11           // c4620529da
+       //TODO: VPCMPEQQ Y11, Y15, Y11          // c4420529db
+       //TODO: VPCMPEQW (BX), X9, X2           // c4e1317513 or c5b17513
+       //TODO: VPCMPEQW (R11), X9, X2          // c4c1317513
+       //TODO: VPCMPEQW X2, X9, X2             // c4e13175d2 or c5b175d2
+       //TODO: VPCMPEQW X11, X9, X2            // c4c13175d3
+       //TODO: VPCMPEQW (BX), X9, X11          // c46131751b or c531751b
+       //TODO: VPCMPEQW (R11), X9, X11         // c44131751b
+       //TODO: VPCMPEQW X2, X9, X11            // c4613175da or c53175da
+       //TODO: VPCMPEQW X11, X9, X11           // c4413175db
+       //TODO: VPCMPEQW (BX), Y15, Y2          // c4e1057513 or c5857513
+       //TODO: VPCMPEQW (R11), Y15, Y2         // c4c1057513
+       //TODO: VPCMPEQW Y2, Y15, Y2            // c4e10575d2 or c58575d2
+       //TODO: VPCMPEQW Y11, Y15, Y2           // c4c10575d3
+       //TODO: VPCMPEQW (BX), Y15, Y11         // c46105751b or c505751b
+       //TODO: VPCMPEQW (R11), Y15, Y11        // c44105751b
+       //TODO: VPCMPEQW Y2, Y15, Y11           // c4610575da or c50575da
+       //TODO: VPCMPEQW Y11, Y15, Y11          // c4410575db
+       //TODO: VPCMPESTRI $7, (BX), X2         // c4e379611307
+       //TODO: VPCMPESTRI $7, (R11), X2        // c4c379611307
+       //TODO: VPCMPESTRI $7, X2, X2           // c4e37961d207
+       //TODO: VPCMPESTRI $7, X11, X2          // c4c37961d307
+       //TODO: VPCMPESTRI $7, (BX), X11        // c46379611b07
+       //TODO: VPCMPESTRI $7, (R11), X11       // c44379611b07
+       //TODO: VPCMPESTRI $7, X2, X11          // c4637961da07
+       //TODO: VPCMPESTRI $7, X11, X11         // c4437961db07
+       //TODO: VPCMPESTRM $7, (BX), X2         // c4e379601307
+       //TODO: VPCMPESTRM $7, (R11), X2        // c4c379601307
+       //TODO: VPCMPESTRM $7, X2, X2           // c4e37960d207
+       //TODO: VPCMPESTRM $7, X11, X2          // c4c37960d307
+       //TODO: VPCMPESTRM $7, (BX), X11        // c46379601b07
+       //TODO: VPCMPESTRM $7, (R11), X11       // c44379601b07
+       //TODO: VPCMPESTRM $7, X2, X11          // c4637960da07
+       //TODO: VPCMPESTRM $7, X11, X11         // c4437960db07
+       //TODO: VPCMPGTB (BX), X9, X2           // c4e1316413 or c5b16413
+       //TODO: VPCMPGTB (R11), X9, X2          // c4c1316413
+       //TODO: VPCMPGTB X2, X9, X2             // c4e13164d2 or c5b164d2
+       //TODO: VPCMPGTB X11, X9, X2            // c4c13164d3
+       //TODO: VPCMPGTB (BX), X9, X11          // c46131641b or c531641b
+       //TODO: VPCMPGTB (R11), X9, X11         // c44131641b
+       //TODO: VPCMPGTB X2, X9, X11            // c4613164da or c53164da
+       //TODO: VPCMPGTB X11, X9, X11           // c4413164db
+       //TODO: VPCMPGTB (BX), Y15, Y2          // c4e1056413 or c5856413
+       //TODO: VPCMPGTB (R11), Y15, Y2         // c4c1056413
+       //TODO: VPCMPGTB Y2, Y15, Y2            // c4e10564d2 or c58564d2
+       //TODO: VPCMPGTB Y11, Y15, Y2           // c4c10564d3
+       //TODO: VPCMPGTB (BX), Y15, Y11         // c46105641b or c505641b
+       //TODO: VPCMPGTB (R11), Y15, Y11        // c44105641b
+       //TODO: VPCMPGTB Y2, Y15, Y11           // c4610564da or c50564da
+       //TODO: VPCMPGTB Y11, Y15, Y11          // c4410564db
+       //TODO: VPCMPGTD (BX), X9, X2           // c4e1316613 or c5b16613
+       //TODO: VPCMPGTD (R11), X9, X2          // c4c1316613
+       //TODO: VPCMPGTD X2, X9, X2             // c4e13166d2 or c5b166d2
+       //TODO: VPCMPGTD X11, X9, X2            // c4c13166d3
+       //TODO: VPCMPGTD (BX), X9, X11          // c46131661b or c531661b
+       //TODO: VPCMPGTD (R11), X9, X11         // c44131661b
+       //TODO: VPCMPGTD X2, X9, X11            // c4613166da or c53166da
+       //TODO: VPCMPGTD X11, X9, X11           // c4413166db
+       //TODO: VPCMPGTD (BX), Y15, Y2          // c4e1056613 or c5856613
+       //TODO: VPCMPGTD (R11), Y15, Y2         // c4c1056613
+       //TODO: VPCMPGTD Y2, Y15, Y2            // c4e10566d2 or c58566d2
+       //TODO: VPCMPGTD Y11, Y15, Y2           // c4c10566d3
+       //TODO: VPCMPGTD (BX), Y15, Y11         // c46105661b or c505661b
+       //TODO: VPCMPGTD (R11), Y15, Y11        // c44105661b
+       //TODO: VPCMPGTD Y2, Y15, Y11           // c4610566da or c50566da
+       //TODO: VPCMPGTD Y11, Y15, Y11          // c4410566db
+       //TODO: VPCMPGTQ (BX), X9, X2           // c4e2313713
+       //TODO: VPCMPGTQ (R11), X9, X2          // c4c2313713
+       //TODO: VPCMPGTQ X2, X9, X2             // c4e23137d2
+       //TODO: VPCMPGTQ X11, X9, X2            // c4c23137d3
+       //TODO: VPCMPGTQ (BX), X9, X11          // c46231371b
+       //TODO: VPCMPGTQ (R11), X9, X11         // c44231371b
+       //TODO: VPCMPGTQ X2, X9, X11            // c4623137da
+       //TODO: VPCMPGTQ X11, X9, X11           // c4423137db
+       //TODO: VPCMPGTQ (BX), Y15, Y2          // c4e2053713
+       //TODO: VPCMPGTQ (R11), Y15, Y2         // c4c2053713
+       //TODO: VPCMPGTQ Y2, Y15, Y2            // c4e20537d2
+       //TODO: VPCMPGTQ Y11, Y15, Y2           // c4c20537d3
+       //TODO: VPCMPGTQ (BX), Y15, Y11         // c46205371b
+       //TODO: VPCMPGTQ (R11), Y15, Y11        // c44205371b
+       //TODO: VPCMPGTQ Y2, Y15, Y11           // c4620537da
+       //TODO: VPCMPGTQ Y11, Y15, Y11          // c4420537db
+       //TODO: VPCMPGTW (BX), X9, X2           // c4e1316513 or c5b16513
+       //TODO: VPCMPGTW (R11), X9, X2          // c4c1316513
+       //TODO: VPCMPGTW X2, X9, X2             // c4e13165d2 or c5b165d2
+       //TODO: VPCMPGTW X11, X9, X2            // c4c13165d3
+       //TODO: VPCMPGTW (BX), X9, X11          // c46131651b or c531651b
+       //TODO: VPCMPGTW (R11), X9, X11         // c44131651b
+       //TODO: VPCMPGTW X2, X9, X11            // c4613165da or c53165da
+       //TODO: VPCMPGTW X11, X9, X11           // c4413165db
+       //TODO: VPCMPGTW (BX), Y15, Y2          // c4e1056513 or c5856513
+       //TODO: VPCMPGTW (R11), Y15, Y2         // c4c1056513
+       //TODO: VPCMPGTW Y2, Y15, Y2            // c4e10565d2 or c58565d2
+       //TODO: VPCMPGTW Y11, Y15, Y2           // c4c10565d3
+       //TODO: VPCMPGTW (BX), Y15, Y11         // c46105651b or c505651b
+       //TODO: VPCMPGTW (R11), Y15, Y11        // c44105651b
+       //TODO: VPCMPGTW Y2, Y15, Y11           // c4610565da or c50565da
+       //TODO: VPCMPGTW Y11, Y15, Y11          // c4410565db
+       //TODO: VPCMPISTRI $7, (BX), X2         // c4e379631307
+       //TODO: VPCMPISTRI $7, (R11), X2        // c4c379631307
+       //TODO: VPCMPISTRI $7, X2, X2           // c4e37963d207
+       //TODO: VPCMPISTRI $7, X11, X2          // c4c37963d307
+       //TODO: VPCMPISTRI $7, (BX), X11        // c46379631b07
+       //TODO: VPCMPISTRI $7, (R11), X11       // c44379631b07
+       //TODO: VPCMPISTRI $7, X2, X11          // c4637963da07
+       //TODO: VPCMPISTRI $7, X11, X11         // c4437963db07
+       //TODO: VPCMPISTRM $7, (BX), X2         // c4e379621307
+       //TODO: VPCMPISTRM $7, (R11), X2        // c4c379621307
+       //TODO: VPCMPISTRM $7, X2, X2           // c4e37962d207
+       //TODO: VPCMPISTRM $7, X11, X2          // c4c37962d307
+       //TODO: VPCMPISTRM $7, (BX), X11        // c46379621b07
+       //TODO: VPCMPISTRM $7, (R11), X11       // c44379621b07
+       //TODO: VPCMPISTRM $7, X2, X11          // c4637962da07
+       //TODO: VPCMPISTRM $7, X11, X11         // c4437962db07
+       //TODO: VPERM2F128 $7, (BX), Y15, Y2    // c4e305061307
+       //TODO: VPERM2F128 $7, (R11), Y15, Y2   // c4c305061307
+       //TODO: VPERM2F128 $7, Y2, Y15, Y2      // c4e30506d207
+       //TODO: VPERM2F128 $7, Y11, Y15, Y2     // c4c30506d307
+       //TODO: VPERM2F128 $7, (BX), Y15, Y11   // c46305061b07
+       //TODO: VPERM2F128 $7, (R11), Y15, Y11  // c44305061b07
+       //TODO: VPERM2F128 $7, Y2, Y15, Y11     // c4630506da07
+       //TODO: VPERM2F128 $7, Y11, Y15, Y11    // c4430506db07
+       //TODO: VPERM2I128 $7, (BX), Y15, Y2    // c4e305461307
+       //TODO: VPERM2I128 $7, (R11), Y15, Y2   // c4c305461307
+       //TODO: VPERM2I128 $7, Y2, Y15, Y2      // c4e30546d207
+       //TODO: VPERM2I128 $7, Y11, Y15, Y2     // c4c30546d307
+       //TODO: VPERM2I128 $7, (BX), Y15, Y11   // c46305461b07
+       //TODO: VPERM2I128 $7, (R11), Y15, Y11  // c44305461b07
+       //TODO: VPERM2I128 $7, Y2, Y15, Y11     // c4630546da07
+       //TODO: VPERM2I128 $7, Y11, Y15, Y11    // c4430546db07
+       //TODO: VPERMD (BX), Y15, Y2            // c4e2053613
+       //TODO: VPERMD (R11), Y15, Y2           // c4c2053613
+       //TODO: VPERMD Y2, Y15, Y2              // c4e20536d2
+       //TODO: VPERMD Y11, Y15, Y2             // c4c20536d3
+       //TODO: VPERMD (BX), Y15, Y11           // c46205361b
+       //TODO: VPERMD (R11), Y15, Y11          // c44205361b
+       //TODO: VPERMD Y2, Y15, Y11             // c4620536da
+       //TODO: VPERMD Y11, Y15, Y11            // c4420536db
+       //TODO: VPERMILPD $7, (BX), X2          // c4e379051307
+       //TODO: VPERMILPD $7, (R11), X2         // c4c379051307
+       //TODO: VPERMILPD $7, X2, X2            // c4e37905d207
+       //TODO: VPERMILPD $7, X11, X2           // c4c37905d307
+       //TODO: VPERMILPD $7, (BX), X11         // c46379051b07
+       //TODO: VPERMILPD $7, (R11), X11        // c44379051b07
+       //TODO: VPERMILPD $7, X2, X11           // c4637905da07
+       //TODO: VPERMILPD $7, X11, X11          // c4437905db07
+       //TODO: VPERMILPD (BX), X9, X2          // c4e2310d13
+       //TODO: VPERMILPD (R11), X9, X2         // c4c2310d13
+       //TODO: VPERMILPD X2, X9, X2            // c4e2310dd2
+       //TODO: VPERMILPD X11, X9, X2           // c4c2310dd3
+       //TODO: VPERMILPD (BX), X9, X11         // c462310d1b
+       //TODO: VPERMILPD (R11), X9, X11        // c442310d1b
+       //TODO: VPERMILPD X2, X9, X11           // c462310dda
+       //TODO: VPERMILPD X11, X9, X11          // c442310ddb
+       //TODO: VPERMILPD $7, (BX), Y2          // c4e37d051307
+       //TODO: VPERMILPD $7, (R11), Y2         // c4c37d051307
+       //TODO: VPERMILPD $7, Y2, Y2            // c4e37d05d207
+       //TODO: VPERMILPD $7, Y11, Y2           // c4c37d05d307
+       //TODO: VPERMILPD $7, (BX), Y11         // c4637d051b07
+       //TODO: VPERMILPD $7, (R11), Y11        // c4437d051b07
+       //TODO: VPERMILPD $7, Y2, Y11           // c4637d05da07
+       //TODO: VPERMILPD $7, Y11, Y11          // c4437d05db07
+       //TODO: VPERMILPD (BX), Y15, Y2         // c4e2050d13
+       //TODO: VPERMILPD (R11), Y15, Y2        // c4c2050d13
+       //TODO: VPERMILPD Y2, Y15, Y2           // c4e2050dd2
+       //TODO: VPERMILPD Y11, Y15, Y2          // c4c2050dd3
+       //TODO: VPERMILPD (BX), Y15, Y11        // c462050d1b
+       //TODO: VPERMILPD (R11), Y15, Y11       // c442050d1b
+       //TODO: VPERMILPD Y2, Y15, Y11          // c462050dda
+       //TODO: VPERMILPD Y11, Y15, Y11         // c442050ddb
+       //TODO: VPERMILPS $7, (BX), X2          // c4e379041307
+       //TODO: VPERMILPS $7, (R11), X2         // c4c379041307
+       //TODO: VPERMILPS $7, X2, X2            // c4e37904d207
+       //TODO: VPERMILPS $7, X11, X2           // c4c37904d307
+       //TODO: VPERMILPS $7, (BX), X11         // c46379041b07
+       //TODO: VPERMILPS $7, (R11), X11        // c44379041b07
+       //TODO: VPERMILPS $7, X2, X11           // c4637904da07
+       //TODO: VPERMILPS $7, X11, X11          // c4437904db07
+       //TODO: VPERMILPS (BX), X9, X2          // c4e2310c13
+       //TODO: VPERMILPS (R11), X9, X2         // c4c2310c13
+       //TODO: VPERMILPS X2, X9, X2            // c4e2310cd2
+       //TODO: VPERMILPS X11, X9, X2           // c4c2310cd3
+       //TODO: VPERMILPS (BX), X9, X11         // c462310c1b
+       //TODO: VPERMILPS (R11), X9, X11        // c442310c1b
+       //TODO: VPERMILPS X2, X9, X11           // c462310cda
+       //TODO: VPERMILPS X11, X9, X11          // c442310cdb
+       //TODO: VPERMILPS $7, (BX), Y2          // c4e37d041307
+       //TODO: VPERMILPS $7, (R11), Y2         // c4c37d041307
+       //TODO: VPERMILPS $7, Y2, Y2            // c4e37d04d207
+       //TODO: VPERMILPS $7, Y11, Y2           // c4c37d04d307
+       //TODO: VPERMILPS $7, (BX), Y11         // c4637d041b07
+       //TODO: VPERMILPS $7, (R11), Y11        // c4437d041b07
+       //TODO: VPERMILPS $7, Y2, Y11           // c4637d04da07
+       //TODO: VPERMILPS $7, Y11, Y11          // c4437d04db07
+       //TODO: VPERMILPS (BX), Y15, Y2         // c4e2050c13
+       //TODO: VPERMILPS (R11), Y15, Y2        // c4c2050c13
+       //TODO: VPERMILPS Y2, Y15, Y2           // c4e2050cd2
+       //TODO: VPERMILPS Y11, Y15, Y2          // c4c2050cd3
+       //TODO: VPERMILPS (BX), Y15, Y11        // c462050c1b
+       //TODO: VPERMILPS (R11), Y15, Y11       // c442050c1b
+       //TODO: VPERMILPS Y2, Y15, Y11          // c462050cda
+       //TODO: VPERMILPS Y11, Y15, Y11         // c442050cdb
+       //TODO: VPERMPD $7, (BX), Y2            // c4e3fd011307
+       //TODO: VPERMPD $7, (R11), Y2           // c4c3fd011307
+       //TODO: VPERMPD $7, Y2, Y2              // c4e3fd01d207
+       //TODO: VPERMPD $7, Y11, Y2             // c4c3fd01d307
+       //TODO: VPERMPD $7, (BX), Y11           // c463fd011b07
+       //TODO: VPERMPD $7, (R11), Y11          // c443fd011b07
+       //TODO: VPERMPD $7, Y2, Y11             // c463fd01da07
+       //TODO: VPERMPD $7, Y11, Y11            // c443fd01db07
+       //TODO: VPERMPS (BX), Y15, Y2           // c4e2051613
+       //TODO: VPERMPS (R11), Y15, Y2          // c4c2051613
+       //TODO: VPERMPS Y2, Y15, Y2             // c4e20516d2
+       //TODO: VPERMPS Y11, Y15, Y2            // c4c20516d3
+       //TODO: VPERMPS (BX), Y15, Y11          // c46205161b
+       //TODO: VPERMPS (R11), Y15, Y11         // c44205161b
+       //TODO: VPERMPS Y2, Y15, Y11            // c4620516da
+       //TODO: VPERMPS Y11, Y15, Y11           // c4420516db
+       //TODO: VPERMQ $7, (BX), Y2             // c4e3fd001307
+       //TODO: VPERMQ $7, (R11), Y2            // c4c3fd001307
+       //TODO: VPERMQ $7, Y2, Y2               // c4e3fd00d207
+       //TODO: VPERMQ $7, Y11, Y2              // c4c3fd00d307
+       //TODO: VPERMQ $7, (BX), Y11            // c463fd001b07
+       //TODO: VPERMQ $7, (R11), Y11           // c443fd001b07
+       //TODO: VPERMQ $7, Y2, Y11              // c463fd00da07
+       //TODO: VPERMQ $7, Y11, Y11             // c443fd00db07
+       //TODO: VPEXTRB $7, X2, (BX)            // c4e379141307
+       //TODO: VPEXTRB $7, X11, (BX)           // c46379141b07
+       //TODO: VPEXTRB $7, X2, (R11)           // c4c379141307
+       //TODO: VPEXTRB $7, X11, (R11)          // c44379141b07
+       //TODO: VPEXTRB $7, X2, DX              // c4e37914d207
+       //TODO: VPEXTRB $7, X11, DX             // c4637914da07
+       //TODO: VPEXTRB $7, X2, R11             // c4c37914d307
+       //TODO: VPEXTRB $7, X11, R11            // c4437914db07
+       //TODO: VPEXTRD $7, X2, (BX)            // c4e379161307
+       //TODO: VPEXTRD $7, X11, (BX)           // c46379161b07
+       //TODO: VPEXTRD $7, X2, (R11)           // c4c379161307
+       //TODO: VPEXTRD $7, X11, (R11)          // c44379161b07
+       //TODO: VPEXTRD $7, X2, DX              // c4e37916d207
+       //TODO: VPEXTRD $7, X11, DX             // c4637916da07
+       //TODO: VPEXTRD $7, X2, R11             // c4c37916d307
+       //TODO: VPEXTRD $7, X11, R11            // c4437916db07
+       //TODO: VPEXTRQ $7, X2, (BX)            // c4e3f9161307
+       //TODO: VPEXTRQ $7, X11, (BX)           // c463f9161b07
+       //TODO: VPEXTRQ $7, X2, (R11)           // c4c3f9161307
+       //TODO: VPEXTRQ $7, X11, (R11)          // c443f9161b07
+       //TODO: VPEXTRQ $7, X2, DX              // c4e3f916d207
+       //TODO: VPEXTRQ $7, X11, DX             // c463f916da07
+       //TODO: VPEXTRQ $7, X2, R11             // c4c3f916d307
+       //TODO: VPEXTRQ $7, X11, R11            // c443f916db07
+       //TODO: VPEXTRW $7, X2, DX              // c4e179c5d207 or c5f9c5d207 or c4e37915d207
+       //TODO: VPEXTRW $7, X11, DX             // c4c179c5d307 or c4637915da07
+       //TODO: VPEXTRW $7, X2, R11             // c46179c5da07 or c579c5da07 or c4c37915d307
+       //TODO: VPEXTRW $7, X11, R11            // c44179c5db07 or c4437915db07
+       //TODO: VPEXTRW $7, X2, (BX)            // c4e379151307
+       //TODO: VPEXTRW $7, X11, (BX)           // c46379151b07
+       //TODO: VPEXTRW $7, X2, (R11)           // c4c379151307
+       //TODO: VPEXTRW $7, X11, (R11)          // c44379151b07
+       //TODO: VPHADDD (BX), X9, X2            // c4e2310213
+       //TODO: VPHADDD (R11), X9, X2           // c4c2310213
+       //TODO: VPHADDD X2, X9, X2              // c4e23102d2
+       //TODO: VPHADDD X11, X9, X2             // c4c23102d3
+       //TODO: VPHADDD (BX), X9, X11           // c46231021b
+       //TODO: VPHADDD (R11), X9, X11          // c44231021b
+       //TODO: VPHADDD X2, X9, X11             // c4623102da
+       //TODO: VPHADDD X11, X9, X11            // c4423102db
+       //TODO: VPHADDD (BX), Y15, Y2           // c4e2050213
+       //TODO: VPHADDD (R11), Y15, Y2          // c4c2050213
+       //TODO: VPHADDD Y2, Y15, Y2             // c4e20502d2
+       //TODO: VPHADDD Y11, Y15, Y2            // c4c20502d3
+       //TODO: VPHADDD (BX), Y15, Y11          // c46205021b
+       //TODO: VPHADDD (R11), Y15, Y11         // c44205021b
+       //TODO: VPHADDD Y2, Y15, Y11            // c4620502da
+       //TODO: VPHADDD Y11, Y15, Y11           // c4420502db
+       //TODO: VPHADDSW (BX), X9, X2           // c4e2310313
+       //TODO: VPHADDSW (R11), X9, X2          // c4c2310313
+       //TODO: VPHADDSW X2, X9, X2             // c4e23103d2
+       //TODO: VPHADDSW X11, X9, X2            // c4c23103d3
+       //TODO: VPHADDSW (BX), X9, X11          // c46231031b
+       //TODO: VPHADDSW (R11), X9, X11         // c44231031b
+       //TODO: VPHADDSW X2, X9, X11            // c4623103da
+       //TODO: VPHADDSW X11, X9, X11           // c4423103db
+       //TODO: VPHADDSW (BX), Y15, Y2          // c4e2050313
+       //TODO: VPHADDSW (R11), Y15, Y2         // c4c2050313
+       //TODO: VPHADDSW Y2, Y15, Y2            // c4e20503d2
+       //TODO: VPHADDSW Y11, Y15, Y2           // c4c20503d3
+       //TODO: VPHADDSW (BX), Y15, Y11         // c46205031b
+       //TODO: VPHADDSW (R11), Y15, Y11        // c44205031b
+       //TODO: VPHADDSW Y2, Y15, Y11           // c4620503da
+       //TODO: VPHADDSW Y11, Y15, Y11          // c4420503db
+       //TODO: VPHADDW (BX), X9, X2            // c4e2310113
+       //TODO: VPHADDW (R11), X9, X2           // c4c2310113
+       //TODO: VPHADDW X2, X9, X2              // c4e23101d2
+       //TODO: VPHADDW X11, X9, X2             // c4c23101d3
+       //TODO: VPHADDW (BX), X9, X11           // c46231011b
+       //TODO: VPHADDW (R11), X9, X11          // c44231011b
+       //TODO: VPHADDW X2, X9, X11             // c4623101da
+       //TODO: VPHADDW X11, X9, X11            // c4423101db
+       //TODO: VPHADDW (BX), Y15, Y2           // c4e2050113
+       //TODO: VPHADDW (R11), Y15, Y2          // c4c2050113
+       //TODO: VPHADDW Y2, Y15, Y2             // c4e20501d2
+       //TODO: VPHADDW Y11, Y15, Y2            // c4c20501d3
+       //TODO: VPHADDW (BX), Y15, Y11          // c46205011b
+       //TODO: VPHADDW (R11), Y15, Y11         // c44205011b
+       //TODO: VPHADDW Y2, Y15, Y11            // c4620501da
+       //TODO: VPHADDW Y11, Y15, Y11           // c4420501db
+       //TODO: VPHMINPOSUW (BX), X2            // c4e2794113
+       //TODO: VPHMINPOSUW (R11), X2           // c4c2794113
+       //TODO: VPHMINPOSUW X2, X2              // c4e27941d2
+       //TODO: VPHMINPOSUW X11, X2             // c4c27941d3
+       //TODO: VPHMINPOSUW (BX), X11           // c46279411b
+       //TODO: VPHMINPOSUW (R11), X11          // c44279411b
+       //TODO: VPHMINPOSUW X2, X11             // c4627941da
+       //TODO: VPHMINPOSUW X11, X11            // c4427941db
+       //TODO: VPHSUBD (BX), X9, X2            // c4e2310613
+       //TODO: VPHSUBD (R11), X9, X2           // c4c2310613
+       //TODO: VPHSUBD X2, X9, X2              // c4e23106d2
+       //TODO: VPHSUBD X11, X9, X2             // c4c23106d3
+       //TODO: VPHSUBD (BX), X9, X11           // c46231061b
+       //TODO: VPHSUBD (R11), X9, X11          // c44231061b
+       //TODO: VPHSUBD X2, X9, X11             // c4623106da
+       //TODO: VPHSUBD X11, X9, X11            // c4423106db
+       //TODO: VPHSUBD (BX), Y15, Y2           // c4e2050613
+       //TODO: VPHSUBD (R11), Y15, Y2          // c4c2050613
+       //TODO: VPHSUBD Y2, Y15, Y2             // c4e20506d2
+       //TODO: VPHSUBD Y11, Y15, Y2            // c4c20506d3
+       //TODO: VPHSUBD (BX), Y15, Y11          // c46205061b
+       //TODO: VPHSUBD (R11), Y15, Y11         // c44205061b
+       //TODO: VPHSUBD Y2, Y15, Y11            // c4620506da
+       //TODO: VPHSUBD Y11, Y15, Y11           // c4420506db
+       //TODO: VPHSUBSW (BX), X9, X2           // c4e2310713
+       //TODO: VPHSUBSW (R11), X9, X2          // c4c2310713
+       //TODO: VPHSUBSW X2, X9, X2             // c4e23107d2
+       //TODO: VPHSUBSW X11, X9, X2            // c4c23107d3
+       //TODO: VPHSUBSW (BX), X9, X11          // c46231071b
+       //TODO: VPHSUBSW (R11), X9, X11         // c44231071b
+       //TODO: VPHSUBSW X2, X9, X11            // c4623107da
+       //TODO: VPHSUBSW X11, X9, X11           // c4423107db
+       //TODO: VPHSUBSW (BX), Y15, Y2          // c4e2050713
+       //TODO: VPHSUBSW (R11), Y15, Y2         // c4c2050713
+       //TODO: VPHSUBSW Y2, Y15, Y2            // c4e20507d2
+       //TODO: VPHSUBSW Y11, Y15, Y2           // c4c20507d3
+       //TODO: VPHSUBSW (BX), Y15, Y11         // c46205071b
+       //TODO: VPHSUBSW (R11), Y15, Y11        // c44205071b
+       //TODO: VPHSUBSW Y2, Y15, Y11           // c4620507da
+       //TODO: VPHSUBSW Y11, Y15, Y11          // c4420507db
+       //TODO: VPHSUBW (BX), X9, X2            // c4e2310513
+       //TODO: VPHSUBW (R11), X9, X2           // c4c2310513
+       //TODO: VPHSUBW X2, X9, X2              // c4e23105d2
+       //TODO: VPHSUBW X11, X9, X2             // c4c23105d3
+       //TODO: VPHSUBW (BX), X9, X11           // c46231051b
+       //TODO: VPHSUBW (R11), X9, X11          // c44231051b
+       //TODO: VPHSUBW X2, X9, X11             // c4623105da
+       //TODO: VPHSUBW X11, X9, X11            // c4423105db
+       //TODO: VPHSUBW (BX), Y15, Y2           // c4e2050513
+       //TODO: VPHSUBW (R11), Y15, Y2          // c4c2050513
+       //TODO: VPHSUBW Y2, Y15, Y2             // c4e20505d2
+       //TODO: VPHSUBW Y11, Y15, Y2            // c4c20505d3
+       //TODO: VPHSUBW (BX), Y15, Y11          // c46205051b
+       //TODO: VPHSUBW (R11), Y15, Y11         // c44205051b
+       //TODO: VPHSUBW Y2, Y15, Y11            // c4620505da
+       //TODO: VPHSUBW Y11, Y15, Y11           // c4420505db
+       //TODO: VPINSRB $7, (BX), X9, X2        // c4e331201307
+       //TODO: VPINSRB $7, (R11), X9, X2       // c4c331201307
+       //TODO: VPINSRB $7, DX, X9, X2          // c4e33120d207
+       //TODO: VPINSRB $7, R11, X9, X2         // c4c33120d307
+       //TODO: VPINSRB $7, (BX), X9, X11       // c46331201b07
+       //TODO: VPINSRB $7, (R11), X9, X11      // c44331201b07
+       //TODO: VPINSRB $7, DX, X9, X11         // c4633120da07
+       //TODO: VPINSRB $7, R11, X9, X11        // c4433120db07
+       //TODO: VPINSRD $7, (BX), X9, X2        // c4e331221307
+       //TODO: VPINSRD $7, (R11), X9, X2       // c4c331221307
+       //TODO: VPINSRD $7, DX, X9, X2          // c4e33122d207
+       //TODO: VPINSRD $7, R11, X9, X2         // c4c33122d307
+       //TODO: VPINSRD $7, (BX), X9, X11       // c46331221b07
+       //TODO: VPINSRD $7, (R11), X9, X11      // c44331221b07
+       //TODO: VPINSRD $7, DX, X9, X11         // c4633122da07
+       //TODO: VPINSRD $7, R11, X9, X11        // c4433122db07
+       //TODO: VPINSRQ $7, (BX), X9, X2        // c4e3b1221307
+       //TODO: VPINSRQ $7, (R11), X9, X2       // c4c3b1221307
+       //TODO: VPINSRQ $7, DX, X9, X2          // c4e3b122d207
+       //TODO: VPINSRQ $7, R11, X9, X2         // c4c3b122d307
+       //TODO: VPINSRQ $7, (BX), X9, X11       // c463b1221b07
+       //TODO: VPINSRQ $7, (R11), X9, X11      // c443b1221b07
+       //TODO: VPINSRQ $7, DX, X9, X11         // c463b122da07
+       //TODO: VPINSRQ $7, R11, X9, X11        // c443b122db07
+       //TODO: VPINSRW $7, (BX), X9, X2        // c4e131c41307 or c5b1c41307
+       //TODO: VPINSRW $7, (R11), X9, X2       // c4c131c41307
+       //TODO: VPINSRW $7, DX, X9, X2          // c4e131c4d207 or c5b1c4d207
+       //TODO: VPINSRW $7, R11, X9, X2         // c4c131c4d307
+       //TODO: VPINSRW $7, (BX), X9, X11       // c46131c41b07 or c531c41b07
+       //TODO: VPINSRW $7, (R11), X9, X11      // c44131c41b07
+       //TODO: VPINSRW $7, DX, X9, X11         // c46131c4da07 or c531c4da07
+       //TODO: VPINSRW $7, R11, X9, X11        // c44131c4db07
+       //TODO: VPMADDUBSW (BX), X9, X2         // c4e2310413
+       //TODO: VPMADDUBSW (R11), X9, X2        // c4c2310413
+       //TODO: VPMADDUBSW X2, X9, X2           // c4e23104d2
+       //TODO: VPMADDUBSW X11, X9, X2          // c4c23104d3
+       //TODO: VPMADDUBSW (BX), X9, X11        // c46231041b
+       //TODO: VPMADDUBSW (R11), X9, X11       // c44231041b
+       //TODO: VPMADDUBSW X2, X9, X11          // c4623104da
+       //TODO: VPMADDUBSW X11, X9, X11         // c4423104db
+       //TODO: VPMADDUBSW (BX), Y15, Y2        // c4e2050413
+       //TODO: VPMADDUBSW (R11), Y15, Y2       // c4c2050413
+       //TODO: VPMADDUBSW Y2, Y15, Y2          // c4e20504d2
+       //TODO: VPMADDUBSW Y11, Y15, Y2         // c4c20504d3
+       //TODO: VPMADDUBSW (BX), Y15, Y11       // c46205041b
+       //TODO: VPMADDUBSW (R11), Y15, Y11      // c44205041b
+       //TODO: VPMADDUBSW Y2, Y15, Y11         // c4620504da
+       //TODO: VPMADDUBSW Y11, Y15, Y11        // c4420504db
+       //TODO: VPMADDWD (BX), X9, X2           // c4e131f513 or c5b1f513
+       //TODO: VPMADDWD (R11), X9, X2          // c4c131f513
+       //TODO: VPMADDWD X2, X9, X2             // c4e131f5d2 or c5b1f5d2
+       //TODO: VPMADDWD X11, X9, X2            // c4c131f5d3
+       //TODO: VPMADDWD (BX), X9, X11          // c46131f51b or c531f51b
+       //TODO: VPMADDWD (R11), X9, X11         // c44131f51b
+       //TODO: VPMADDWD X2, X9, X11            // c46131f5da or c531f5da
+       //TODO: VPMADDWD X11, X9, X11           // c44131f5db
+       //TODO: VPMADDWD (BX), Y15, Y2          // c4e105f513 or c585f513
+       //TODO: VPMADDWD (R11), Y15, Y2         // c4c105f513
+       //TODO: VPMADDWD Y2, Y15, Y2            // c4e105f5d2 or c585f5d2
+       //TODO: VPMADDWD Y11, Y15, Y2           // c4c105f5d3
+       //TODO: VPMADDWD (BX), Y15, Y11         // c46105f51b or c505f51b
+       //TODO: VPMADDWD (R11), Y15, Y11        // c44105f51b
+       //TODO: VPMADDWD Y2, Y15, Y11           // c46105f5da or c505f5da
+       //TODO: VPMADDWD Y11, Y15, Y11          // c44105f5db
+       //TODO: VPMASKMOVD X2, X9, (BX)         // c4e2318e13
+       //TODO: VPMASKMOVD X11, X9, (BX)        // c462318e1b
+       //TODO: VPMASKMOVD X2, X9, (R11)        // c4c2318e13
+       //TODO: VPMASKMOVD X11, X9, (R11)       // c442318e1b
+       //TODO: VPMASKMOVD Y2, Y15, (BX)        // c4e2058e13
+       //TODO: VPMASKMOVD Y11, Y15, (BX)       // c462058e1b
+       //TODO: VPMASKMOVD Y2, Y15, (R11)       // c4c2058e13
+       //TODO: VPMASKMOVD Y11, Y15, (R11)      // c442058e1b
+       //TODO: VPMASKMOVD (BX), X9, X2         // c4e2318c13
+       //TODO: VPMASKMOVD (R11), X9, X2        // c4c2318c13
+       //TODO: VPMASKMOVD (BX), X9, X11        // c462318c1b
+       //TODO: VPMASKMOVD (R11), X9, X11       // c442318c1b
+       //TODO: VPMASKMOVD (BX), Y15, Y2        // c4e2058c13
+       //TODO: VPMASKMOVD (R11), Y15, Y2       // c4c2058c13
+       //TODO: VPMASKMOVD (BX), Y15, Y11       // c462058c1b
+       //TODO: VPMASKMOVD (R11), Y15, Y11      // c442058c1b
+       //TODO: VPMASKMOVQ X2, X9, (BX)         // c4e2b18e13
+       //TODO: VPMASKMOVQ X11, X9, (BX)        // c462b18e1b
+       //TODO: VPMASKMOVQ X2, X9, (R11)        // c4c2b18e13
+       //TODO: VPMASKMOVQ X11, X9, (R11)       // c442b18e1b
+       //TODO: VPMASKMOVQ Y2, Y15, (BX)        // c4e2858e13
+       //TODO: VPMASKMOVQ Y11, Y15, (BX)       // c462858e1b
+       //TODO: VPMASKMOVQ Y2, Y15, (R11)       // c4c2858e13
+       //TODO: VPMASKMOVQ Y11, Y15, (R11)      // c442858e1b
+       //TODO: VPMASKMOVQ (BX), X9, X2         // c4e2b18c13
+       //TODO: VPMASKMOVQ (R11), X9, X2        // c4c2b18c13
+       //TODO: VPMASKMOVQ (BX), X9, X11        // c462b18c1b
+       //TODO: VPMASKMOVQ (R11), X9, X11       // c442b18c1b
+       //TODO: VPMASKMOVQ (BX), Y15, Y2        // c4e2858c13
+       //TODO: VPMASKMOVQ (R11), Y15, Y2       // c4c2858c13
+       //TODO: VPMASKMOVQ (BX), Y15, Y11       // c462858c1b
+       //TODO: VPMASKMOVQ (R11), Y15, Y11      // c442858c1b
+       //TODO: VPMAXSB (BX), X9, X2            // c4e2313c13
+       //TODO: VPMAXSB (R11), X9, X2           // c4c2313c13
+       //TODO: VPMAXSB X2, X9, X2              // c4e2313cd2
+       //TODO: VPMAXSB X11, X9, X2             // c4c2313cd3
+       //TODO: VPMAXSB (BX), X9, X11           // c462313c1b
+       //TODO: VPMAXSB (R11), X9, X11          // c442313c1b
+       //TODO: VPMAXSB X2, X9, X11             // c462313cda
+       //TODO: VPMAXSB X11, X9, X11            // c442313cdb
+       //TODO: VPMAXSB (BX), Y15, Y2           // c4e2053c13
+       //TODO: VPMAXSB (R11), Y15, Y2          // c4c2053c13
+       //TODO: VPMAXSB Y2, Y15, Y2             // c4e2053cd2
+       //TODO: VPMAXSB Y11, Y15, Y2            // c4c2053cd3
+       //TODO: VPMAXSB (BX), Y15, Y11          // c462053c1b
+       //TODO: VPMAXSB (R11), Y15, Y11         // c442053c1b
+       //TODO: VPMAXSB Y2, Y15, Y11            // c462053cda
+       //TODO: VPMAXSB Y11, Y15, Y11           // c442053cdb
+       //TODO: VPMAXSD (BX), X9, X2            // c4e2313d13
+       //TODO: VPMAXSD (R11), X9, X2           // c4c2313d13
+       //TODO: VPMAXSD X2, X9, X2              // c4e2313dd2
+       //TODO: VPMAXSD X11, X9, X2             // c4c2313dd3
+       //TODO: VPMAXSD (BX), X9, X11           // c462313d1b
+       //TODO: VPMAXSD (R11), X9, X11          // c442313d1b
+       //TODO: VPMAXSD X2, X9, X11             // c462313dda
+       //TODO: VPMAXSD X11, X9, X11            // c442313ddb
+       //TODO: VPMAXSD (BX), Y15, Y2           // c4e2053d13
+       //TODO: VPMAXSD (R11), Y15, Y2          // c4c2053d13
+       //TODO: VPMAXSD Y2, Y15, Y2             // c4e2053dd2
+       //TODO: VPMAXSD Y11, Y15, Y2            // c4c2053dd3
+       //TODO: VPMAXSD (BX), Y15, Y11          // c462053d1b
+       //TODO: VPMAXSD (R11), Y15, Y11         // c442053d1b
+       //TODO: VPMAXSD Y2, Y15, Y11            // c462053dda
+       //TODO: VPMAXSD Y11, Y15, Y11           // c442053ddb
+       //TODO: VPMAXSW (BX), X9, X2            // c4e131ee13 or c5b1ee13
+       //TODO: VPMAXSW (R11), X9, X2           // c4c131ee13
+       //TODO: VPMAXSW X2, X9, X2              // c4e131eed2 or c5b1eed2
+       //TODO: VPMAXSW X11, X9, X2             // c4c131eed3
+       //TODO: VPMAXSW (BX), X9, X11           // c46131ee1b or c531ee1b
+       //TODO: VPMAXSW (R11), X9, X11          // c44131ee1b
+       //TODO: VPMAXSW X2, X9, X11             // c46131eeda or c531eeda
+       //TODO: VPMAXSW X11, X9, X11            // c44131eedb
+       //TODO: VPMAXSW (BX), Y15, Y2           // c4e105ee13 or c585ee13
+       //TODO: VPMAXSW (R11), Y15, Y2          // c4c105ee13
+       //TODO: VPMAXSW Y2, Y15, Y2             // c4e105eed2 or c585eed2
+       //TODO: VPMAXSW Y11, Y15, Y2            // c4c105eed3
+       //TODO: VPMAXSW (BX), Y15, Y11          // c46105ee1b or c505ee1b
+       //TODO: VPMAXSW (R11), Y15, Y11         // c44105ee1b
+       //TODO: VPMAXSW Y2, Y15, Y11            // c46105eeda or c505eeda
+       //TODO: VPMAXSW Y11, Y15, Y11           // c44105eedb
+       //TODO: VPMAXUB (BX), X9, X2            // c4e131de13 or c5b1de13
+       //TODO: VPMAXUB (R11), X9, X2           // c4c131de13
+       //TODO: VPMAXUB X2, X9, X2              // c4e131ded2 or c5b1ded2
+       //TODO: VPMAXUB X11, X9, X2             // c4c131ded3
+       //TODO: VPMAXUB (BX), X9, X11           // c46131de1b or c531de1b
+       //TODO: VPMAXUB (R11), X9, X11          // c44131de1b
+       //TODO: VPMAXUB X2, X9, X11             // c46131deda or c531deda
+       //TODO: VPMAXUB X11, X9, X11            // c44131dedb
+       //TODO: VPMAXUB (BX), Y15, Y2           // c4e105de13 or c585de13
+       //TODO: VPMAXUB (R11), Y15, Y2          // c4c105de13
+       //TODO: VPMAXUB Y2, Y15, Y2             // c4e105ded2 or c585ded2
+       //TODO: VPMAXUB Y11, Y15, Y2            // c4c105ded3
+       //TODO: VPMAXUB (BX), Y15, Y11          // c46105de1b or c505de1b
+       //TODO: VPMAXUB (R11), Y15, Y11         // c44105de1b
+       //TODO: VPMAXUB Y2, Y15, Y11            // c46105deda or c505deda
+       //TODO: VPMAXUB Y11, Y15, Y11           // c44105dedb
+       //TODO: VPMAXUD (BX), X9, X2            // c4e2313f13
+       //TODO: VPMAXUD (R11), X9, X2           // c4c2313f13
+       //TODO: VPMAXUD X2, X9, X2              // c4e2313fd2
+       //TODO: VPMAXUD X11, X9, X2             // c4c2313fd3
+       //TODO: VPMAXUD (BX), X9, X11           // c462313f1b
+       //TODO: VPMAXUD (R11), X9, X11          // c442313f1b
+       //TODO: VPMAXUD X2, X9, X11             // c462313fda
+       //TODO: VPMAXUD X11, X9, X11            // c442313fdb
+       //TODO: VPMAXUD (BX), Y15, Y2           // c4e2053f13
+       //TODO: VPMAXUD (R11), Y15, Y2          // c4c2053f13
+       //TODO: VPMAXUD Y2, Y15, Y2             // c4e2053fd2
+       //TODO: VPMAXUD Y11, Y15, Y2            // c4c2053fd3
+       //TODO: VPMAXUD (BX), Y15, Y11          // c462053f1b
+       //TODO: VPMAXUD (R11), Y15, Y11         // c442053f1b
+       //TODO: VPMAXUD Y2, Y15, Y11            // c462053fda
+       //TODO: VPMAXUD Y11, Y15, Y11           // c442053fdb
+       //TODO: VPMAXUW (BX), X9, X2            // c4e2313e13
+       //TODO: VPMAXUW (R11), X9, X2           // c4c2313e13
+       //TODO: VPMAXUW X2, X9, X2              // c4e2313ed2
+       //TODO: VPMAXUW X11, X9, X2             // c4c2313ed3
+       //TODO: VPMAXUW (BX), X9, X11           // c462313e1b
+       //TODO: VPMAXUW (R11), X9, X11          // c442313e1b
+       //TODO: VPMAXUW X2, X9, X11             // c462313eda
+       //TODO: VPMAXUW X11, X9, X11            // c442313edb
+       //TODO: VPMAXUW (BX), Y15, Y2           // c4e2053e13
+       //TODO: VPMAXUW (R11), Y15, Y2          // c4c2053e13
+       //TODO: VPMAXUW Y2, Y15, Y2             // c4e2053ed2
+       //TODO: VPMAXUW Y11, Y15, Y2            // c4c2053ed3
+       //TODO: VPMAXUW (BX), Y15, Y11          // c462053e1b
+       //TODO: VPMAXUW (R11), Y15, Y11         // c442053e1b
+       //TODO: VPMAXUW Y2, Y15, Y11            // c462053eda
+       //TODO: VPMAXUW Y11, Y15, Y11           // c442053edb
+       //TODO: VPMINSB (BX), X9, X2            // c4e2313813
+       //TODO: VPMINSB (R11), X9, X2           // c4c2313813
+       //TODO: VPMINSB X2, X9, X2              // c4e23138d2
+       //TODO: VPMINSB X11, X9, X2             // c4c23138d3
+       //TODO: VPMINSB (BX), X9, X11           // c46231381b
+       //TODO: VPMINSB (R11), X9, X11          // c44231381b
+       //TODO: VPMINSB X2, X9, X11             // c4623138da
+       //TODO: VPMINSB X11, X9, X11            // c4423138db
+       //TODO: VPMINSB (BX), Y15, Y2           // c4e2053813
+       //TODO: VPMINSB (R11), Y15, Y2          // c4c2053813
+       //TODO: VPMINSB Y2, Y15, Y2             // c4e20538d2
+       //TODO: VPMINSB Y11, Y15, Y2            // c4c20538d3
+       //TODO: VPMINSB (BX), Y15, Y11          // c46205381b
+       //TODO: VPMINSB (R11), Y15, Y11         // c44205381b
+       //TODO: VPMINSB Y2, Y15, Y11            // c4620538da
+       //TODO: VPMINSB Y11, Y15, Y11           // c4420538db
+       //TODO: VPMINSD (BX), X9, X2            // c4e2313913
+       //TODO: VPMINSD (R11), X9, X2           // c4c2313913
+       //TODO: VPMINSD X2, X9, X2              // c4e23139d2
+       //TODO: VPMINSD X11, X9, X2             // c4c23139d3
+       //TODO: VPMINSD (BX), X9, X11           // c46231391b
+       //TODO: VPMINSD (R11), X9, X11          // c44231391b
+       //TODO: VPMINSD X2, X9, X11             // c4623139da
+       //TODO: VPMINSD X11, X9, X11            // c4423139db
+       //TODO: VPMINSD (BX), Y15, Y2           // c4e2053913
+       //TODO: VPMINSD (R11), Y15, Y2          // c4c2053913
+       //TODO: VPMINSD Y2, Y15, Y2             // c4e20539d2
+       //TODO: VPMINSD Y11, Y15, Y2            // c4c20539d3
+       //TODO: VPMINSD (BX), Y15, Y11          // c46205391b
+       //TODO: VPMINSD (R11), Y15, Y11         // c44205391b
+       //TODO: VPMINSD Y2, Y15, Y11            // c4620539da
+       //TODO: VPMINSD Y11, Y15, Y11           // c4420539db
+       //TODO: VPMINSW (BX), X9, X2            // c4e131ea13 or c5b1ea13
+       //TODO: VPMINSW (R11), X9, X2           // c4c131ea13
+       //TODO: VPMINSW X2, X9, X2              // c4e131ead2 or c5b1ead2
+       //TODO: VPMINSW X11, X9, X2             // c4c131ead3
+       //TODO: VPMINSW (BX), X9, X11           // c46131ea1b or c531ea1b
+       //TODO: VPMINSW (R11), X9, X11          // c44131ea1b
+       //TODO: VPMINSW X2, X9, X11             // c46131eada or c531eada
+       //TODO: VPMINSW X11, X9, X11            // c44131eadb
+       //TODO: VPMINSW (BX), Y15, Y2           // c4e105ea13 or c585ea13
+       //TODO: VPMINSW (R11), Y15, Y2          // c4c105ea13
+       //TODO: VPMINSW Y2, Y15, Y2             // c4e105ead2 or c585ead2
+       //TODO: VPMINSW Y11, Y15, Y2            // c4c105ead3
+       //TODO: VPMINSW (BX), Y15, Y11          // c46105ea1b or c505ea1b
+       //TODO: VPMINSW (R11), Y15, Y11         // c44105ea1b
+       //TODO: VPMINSW Y2, Y15, Y11            // c46105eada or c505eada
+       //TODO: VPMINSW Y11, Y15, Y11           // c44105eadb
+       //TODO: VPMINUB (BX), X9, X2            // c4e131da13 or c5b1da13
+       //TODO: VPMINUB (R11), X9, X2           // c4c131da13
+       //TODO: VPMINUB X2, X9, X2              // c4e131dad2 or c5b1dad2
+       //TODO: VPMINUB X11, X9, X2             // c4c131dad3
+       //TODO: VPMINUB (BX), X9, X11           // c46131da1b or c531da1b
+       //TODO: VPMINUB (R11), X9, X11          // c44131da1b
+       //TODO: VPMINUB X2, X9, X11             // c46131dada or c531dada
+       //TODO: VPMINUB X11, X9, X11            // c44131dadb
+       //TODO: VPMINUB (BX), Y15, Y2           // c4e105da13 or c585da13
+       //TODO: VPMINUB (R11), Y15, Y2          // c4c105da13
+       //TODO: VPMINUB Y2, Y15, Y2             // c4e105dad2 or c585dad2
+       //TODO: VPMINUB Y11, Y15, Y2            // c4c105dad3
+       //TODO: VPMINUB (BX), Y15, Y11          // c46105da1b or c505da1b
+       //TODO: VPMINUB (R11), Y15, Y11         // c44105da1b
+       //TODO: VPMINUB Y2, Y15, Y11            // c46105dada or c505dada
+       //TODO: VPMINUB Y11, Y15, Y11           // c44105dadb
+       //TODO: VPMINUD (BX), X9, X2            // c4e2313b13
+       //TODO: VPMINUD (R11), X9, X2           // c4c2313b13
+       //TODO: VPMINUD X2, X9, X2              // c4e2313bd2
+       //TODO: VPMINUD X11, X9, X2             // c4c2313bd3
+       //TODO: VPMINUD (BX), X9, X11           // c462313b1b
+       //TODO: VPMINUD (R11), X9, X11          // c442313b1b
+       //TODO: VPMINUD X2, X9, X11             // c462313bda
+       //TODO: VPMINUD X11, X9, X11            // c442313bdb
+       //TODO: VPMINUD (BX), Y15, Y2           // c4e2053b13
+       //TODO: VPMINUD (R11), Y15, Y2          // c4c2053b13
+       //TODO: VPMINUD Y2, Y15, Y2             // c4e2053bd2
+       //TODO: VPMINUD Y11, Y15, Y2            // c4c2053bd3
+       //TODO: VPMINUD (BX), Y15, Y11          // c462053b1b
+       //TODO: VPMINUD (R11), Y15, Y11         // c442053b1b
+       //TODO: VPMINUD Y2, Y15, Y11            // c462053bda
+       //TODO: VPMINUD Y11, Y15, Y11           // c442053bdb
+       //TODO: VPMINUW (BX), X9, X2            // c4e2313a13
+       //TODO: VPMINUW (R11), X9, X2           // c4c2313a13
+       //TODO: VPMINUW X2, X9, X2              // c4e2313ad2
+       //TODO: VPMINUW X11, X9, X2             // c4c2313ad3
+       //TODO: VPMINUW (BX), X9, X11           // c462313a1b
+       //TODO: VPMINUW (R11), X9, X11          // c442313a1b
+       //TODO: VPMINUW X2, X9, X11             // c462313ada
+       //TODO: VPMINUW X11, X9, X11            // c442313adb
+       //TODO: VPMINUW (BX), Y15, Y2           // c4e2053a13
+       //TODO: VPMINUW (R11), Y15, Y2          // c4c2053a13
+       //TODO: VPMINUW Y2, Y15, Y2             // c4e2053ad2
+       //TODO: VPMINUW Y11, Y15, Y2            // c4c2053ad3
+       //TODO: VPMINUW (BX), Y15, Y11          // c462053a1b
+       //TODO: VPMINUW (R11), Y15, Y11         // c442053a1b
+       //TODO: VPMINUW Y2, Y15, Y11            // c462053ada
+       //TODO: VPMINUW Y11, Y15, Y11           // c442053adb
+       VPMOVMSKB X2, DX                        // c4e179d7d2 or c5f9d7d2
+       VPMOVMSKB X11, DX                       // c4c179d7d3
+       VPMOVMSKB X2, R11                       // c46179d7da or c579d7da
+       VPMOVMSKB X11, R11                      // c44179d7db
+       VPMOVMSKB Y2, DX                        // c4e17dd7d2 or c5fdd7d2
+       VPMOVMSKB Y11, DX                       // c4c17dd7d3
+       VPMOVMSKB Y2, R11                       // c4617dd7da or c57dd7da
+       VPMOVMSKB Y11, R11                      // c4417dd7db
+       //TODO: VPMOVSXBD (BX), X2              // c4e2792113
+       //TODO: VPMOVSXBD (R11), X2             // c4c2792113
+       //TODO: VPMOVSXBD X2, X2                // c4e27921d2
+       //TODO: VPMOVSXBD X11, X2               // c4c27921d3
+       //TODO: VPMOVSXBD (BX), X11             // c46279211b
+       //TODO: VPMOVSXBD (R11), X11            // c44279211b
+       //TODO: VPMOVSXBD X2, X11               // c4627921da
+       //TODO: VPMOVSXBD X11, X11              // c4427921db
+       //TODO: VPMOVSXBD (BX), Y2              // c4e27d2113
+       //TODO: VPMOVSXBD (R11), Y2             // c4c27d2113
+       //TODO: VPMOVSXBD X2, Y2                // c4e27d21d2
+       //TODO: VPMOVSXBD X11, Y2               // c4c27d21d3
+       //TODO: VPMOVSXBD (BX), Y11             // c4627d211b
+       //TODO: VPMOVSXBD (R11), Y11            // c4427d211b
+       //TODO: VPMOVSXBD X2, Y11               // c4627d21da
+       //TODO: VPMOVSXBD X11, Y11              // c4427d21db
+       //TODO: VPMOVSXBQ (BX), X2              // c4e2792213
+       //TODO: VPMOVSXBQ (R11), X2             // c4c2792213
+       //TODO: VPMOVSXBQ X2, X2                // c4e27922d2
+       //TODO: VPMOVSXBQ X11, X2               // c4c27922d3
+       //TODO: VPMOVSXBQ (BX), X11             // c46279221b
+       //TODO: VPMOVSXBQ (R11), X11            // c44279221b
+       //TODO: VPMOVSXBQ X2, X11               // c4627922da
+       //TODO: VPMOVSXBQ X11, X11              // c4427922db
+       //TODO: VPMOVSXBQ (BX), Y2              // c4e27d2213
+       //TODO: VPMOVSXBQ (R11), Y2             // c4c27d2213
+       //TODO: VPMOVSXBQ X2, Y2                // c4e27d22d2
+       //TODO: VPMOVSXBQ X11, Y2               // c4c27d22d3
+       //TODO: VPMOVSXBQ (BX), Y11             // c4627d221b
+       //TODO: VPMOVSXBQ (R11), Y11            // c4427d221b
+       //TODO: VPMOVSXBQ X2, Y11               // c4627d22da
+       //TODO: VPMOVSXBQ X11, Y11              // c4427d22db
+       //TODO: VPMOVSXBW (BX), X2              // c4e2792013
+       //TODO: VPMOVSXBW (R11), X2             // c4c2792013
+       //TODO: VPMOVSXBW X2, X2                // c4e27920d2
+       //TODO: VPMOVSXBW X11, X2               // c4c27920d3
+       //TODO: VPMOVSXBW (BX), X11             // c46279201b
+       //TODO: VPMOVSXBW (R11), X11            // c44279201b
+       //TODO: VPMOVSXBW X2, X11               // c4627920da
+       //TODO: VPMOVSXBW X11, X11              // c4427920db
+       //TODO: VPMOVSXBW (BX), Y2              // c4e27d2013
+       //TODO: VPMOVSXBW (R11), Y2             // c4c27d2013
+       //TODO: VPMOVSXBW X2, Y2                // c4e27d20d2
+       //TODO: VPMOVSXBW X11, Y2               // c4c27d20d3
+       //TODO: VPMOVSXBW (BX), Y11             // c4627d201b
+       //TODO: VPMOVSXBW (R11), Y11            // c4427d201b
+       //TODO: VPMOVSXBW X2, Y11               // c4627d20da
+       //TODO: VPMOVSXBW X11, Y11              // c4427d20db
+       //TODO: VPMOVSXDQ (BX), X2              // c4e2792513
+       //TODO: VPMOVSXDQ (R11), X2             // c4c2792513
+       //TODO: VPMOVSXDQ X2, X2                // c4e27925d2
+       //TODO: VPMOVSXDQ X11, X2               // c4c27925d3
+       //TODO: VPMOVSXDQ (BX), X11             // c46279251b
+       //TODO: VPMOVSXDQ (R11), X11            // c44279251b
+       //TODO: VPMOVSXDQ X2, X11               // c4627925da
+       //TODO: VPMOVSXDQ X11, X11              // c4427925db
+       //TODO: VPMOVSXDQ (BX), Y2              // c4e27d2513
+       //TODO: VPMOVSXDQ (R11), Y2             // c4c27d2513
+       //TODO: VPMOVSXDQ X2, Y2                // c4e27d25d2
+       //TODO: VPMOVSXDQ X11, Y2               // c4c27d25d3
+       //TODO: VPMOVSXDQ (BX), Y11             // c4627d251b
+       //TODO: VPMOVSXDQ (R11), Y11            // c4427d251b
+       //TODO: VPMOVSXDQ X2, Y11               // c4627d25da
+       //TODO: VPMOVSXDQ X11, Y11              // c4427d25db
+       //TODO: VPMOVSXWD (BX), X2              // c4e2792313
+       //TODO: VPMOVSXWD (R11), X2             // c4c2792313
+       //TODO: VPMOVSXWD X2, X2                // c4e27923d2
+       //TODO: VPMOVSXWD X11, X2               // c4c27923d3
+       //TODO: VPMOVSXWD (BX), X11             // c46279231b
+       //TODO: VPMOVSXWD (R11), X11            // c44279231b
+       //TODO: VPMOVSXWD X2, X11               // c4627923da
+       //TODO: VPMOVSXWD X11, X11              // c4427923db
+       //TODO: VPMOVSXWD (BX), Y2              // c4e27d2313
+       //TODO: VPMOVSXWD (R11), Y2             // c4c27d2313
+       //TODO: VPMOVSXWD X2, Y2                // c4e27d23d2
+       //TODO: VPMOVSXWD X11, Y2               // c4c27d23d3
+       //TODO: VPMOVSXWD (BX), Y11             // c4627d231b
+       //TODO: VPMOVSXWD (R11), Y11            // c4427d231b
+       //TODO: VPMOVSXWD X2, Y11               // c4627d23da
+       //TODO: VPMOVSXWD X11, Y11              // c4427d23db
+       //TODO: VPMOVSXWQ (BX), X2              // c4e2792413
+       //TODO: VPMOVSXWQ (R11), X2             // c4c2792413
+       //TODO: VPMOVSXWQ X2, X2                // c4e27924d2
+       //TODO: VPMOVSXWQ X11, X2               // c4c27924d3
+       //TODO: VPMOVSXWQ (BX), X11             // c46279241b
+       //TODO: VPMOVSXWQ (R11), X11            // c44279241b
+       //TODO: VPMOVSXWQ X2, X11               // c4627924da
+       //TODO: VPMOVSXWQ X11, X11              // c4427924db
+       //TODO: VPMOVSXWQ (BX), Y2              // c4e27d2413
+       //TODO: VPMOVSXWQ (R11), Y2             // c4c27d2413
+       //TODO: VPMOVSXWQ X2, Y2                // c4e27d24d2
+       //TODO: VPMOVSXWQ X11, Y2               // c4c27d24d3
+       //TODO: VPMOVSXWQ (BX), Y11             // c4627d241b
+       //TODO: VPMOVSXWQ (R11), Y11            // c4427d241b
+       //TODO: VPMOVSXWQ X2, Y11               // c4627d24da
+       //TODO: VPMOVSXWQ X11, Y11              // c4427d24db
+       //TODO: VPMOVZXBD (BX), X2              // c4e2793113
+       //TODO: VPMOVZXBD (R11), X2             // c4c2793113
+       //TODO: VPMOVZXBD X2, X2                // c4e27931d2
+       //TODO: VPMOVZXBD X11, X2               // c4c27931d3
+       //TODO: VPMOVZXBD (BX), X11             // c46279311b
+       //TODO: VPMOVZXBD (R11), X11            // c44279311b
+       //TODO: VPMOVZXBD X2, X11               // c4627931da
+       //TODO: VPMOVZXBD X11, X11              // c4427931db
+       //TODO: VPMOVZXBD (BX), Y2              // c4e27d3113
+       //TODO: VPMOVZXBD (R11), Y2             // c4c27d3113
+       //TODO: VPMOVZXBD X2, Y2                // c4e27d31d2
+       //TODO: VPMOVZXBD X11, Y2               // c4c27d31d3
+       //TODO: VPMOVZXBD (BX), Y11             // c4627d311b
+       //TODO: VPMOVZXBD (R11), Y11            // c4427d311b
+       //TODO: VPMOVZXBD X2, Y11               // c4627d31da
+       //TODO: VPMOVZXBD X11, Y11              // c4427d31db
+       //TODO: VPMOVZXBQ (BX), X2              // c4e2793213
+       //TODO: VPMOVZXBQ (R11), X2             // c4c2793213
+       //TODO: VPMOVZXBQ X2, X2                // c4e27932d2
+       //TODO: VPMOVZXBQ X11, X2               // c4c27932d3
+       //TODO: VPMOVZXBQ (BX), X11             // c46279321b
+       //TODO: VPMOVZXBQ (R11), X11            // c44279321b
+       //TODO: VPMOVZXBQ X2, X11               // c4627932da
+       //TODO: VPMOVZXBQ X11, X11              // c4427932db
+       //TODO: VPMOVZXBQ (BX), Y2              // c4e27d3213
+       //TODO: VPMOVZXBQ (R11), Y2             // c4c27d3213
+       //TODO: VPMOVZXBQ X2, Y2                // c4e27d32d2
+       //TODO: VPMOVZXBQ X11, Y2               // c4c27d32d3
+       //TODO: VPMOVZXBQ (BX), Y11             // c4627d321b
+       //TODO: VPMOVZXBQ (R11), Y11            // c4427d321b
+       //TODO: VPMOVZXBQ X2, Y11               // c4627d32da
+       //TODO: VPMOVZXBQ X11, Y11              // c4427d32db
+       //TODO: VPMOVZXBW (BX), X2              // c4e2793013
+       //TODO: VPMOVZXBW (R11), X2             // c4c2793013
+       //TODO: VPMOVZXBW X2, X2                // c4e27930d2
+       //TODO: VPMOVZXBW X11, X2               // c4c27930d3
+       //TODO: VPMOVZXBW (BX), X11             // c46279301b
+       //TODO: VPMOVZXBW (R11), X11            // c44279301b
+       //TODO: VPMOVZXBW X2, X11               // c4627930da
+       //TODO: VPMOVZXBW X11, X11              // c4427930db
+       //TODO: VPMOVZXBW (BX), Y2              // c4e27d3013
+       //TODO: VPMOVZXBW (R11), Y2             // c4c27d3013
+       //TODO: VPMOVZXBW X2, Y2                // c4e27d30d2
+       //TODO: VPMOVZXBW X11, Y2               // c4c27d30d3
+       //TODO: VPMOVZXBW (BX), Y11             // c4627d301b
+       //TODO: VPMOVZXBW (R11), Y11            // c4427d301b
+       //TODO: VPMOVZXBW X2, Y11               // c4627d30da
+       //TODO: VPMOVZXBW X11, Y11              // c4427d30db
+       //TODO: VPMOVZXDQ (BX), X2              // c4e2793513
+       //TODO: VPMOVZXDQ (R11), X2             // c4c2793513
+       //TODO: VPMOVZXDQ X2, X2                // c4e27935d2
+       //TODO: VPMOVZXDQ X11, X2               // c4c27935d3
+       //TODO: VPMOVZXDQ (BX), X11             // c46279351b
+       //TODO: VPMOVZXDQ (R11), X11            // c44279351b
+       //TODO: VPMOVZXDQ X2, X11               // c4627935da
+       //TODO: VPMOVZXDQ X11, X11              // c4427935db
+       //TODO: VPMOVZXDQ (BX), Y2              // c4e27d3513
+       //TODO: VPMOVZXDQ (R11), Y2             // c4c27d3513
+       //TODO: VPMOVZXDQ X2, Y2                // c4e27d35d2
+       //TODO: VPMOVZXDQ X11, Y2               // c4c27d35d3
+       //TODO: VPMOVZXDQ (BX), Y11             // c4627d351b
+       //TODO: VPMOVZXDQ (R11), Y11            // c4427d351b
+       //TODO: VPMOVZXDQ X2, Y11               // c4627d35da
+       //TODO: VPMOVZXDQ X11, Y11              // c4427d35db
+       //TODO: VPMOVZXWD (BX), X2              // c4e2793313
+       //TODO: VPMOVZXWD (R11), X2             // c4c2793313
+       //TODO: VPMOVZXWD X2, X2                // c4e27933d2
+       //TODO: VPMOVZXWD X11, X2               // c4c27933d3
+       //TODO: VPMOVZXWD (BX), X11             // c46279331b
+       //TODO: VPMOVZXWD (R11), X11            // c44279331b
+       //TODO: VPMOVZXWD X2, X11               // c4627933da
+       //TODO: VPMOVZXWD X11, X11              // c4427933db
+       //TODO: VPMOVZXWD (BX), Y2              // c4e27d3313
+       //TODO: VPMOVZXWD (R11), Y2             // c4c27d3313
+       //TODO: VPMOVZXWD X2, Y2                // c4e27d33d2
+       //TODO: VPMOVZXWD X11, Y2               // c4c27d33d3
+       //TODO: VPMOVZXWD (BX), Y11             // c4627d331b
+       //TODO: VPMOVZXWD (R11), Y11            // c4427d331b
+       //TODO: VPMOVZXWD X2, Y11               // c4627d33da
+       //TODO: VPMOVZXWD X11, Y11              // c4427d33db
+       //TODO: VPMOVZXWQ (BX), X2              // c4e2793413
+       //TODO: VPMOVZXWQ (R11), X2             // c4c2793413
+       //TODO: VPMOVZXWQ X2, X2                // c4e27934d2
+       //TODO: VPMOVZXWQ X11, X2               // c4c27934d3
+       //TODO: VPMOVZXWQ (BX), X11             // c46279341b
+       //TODO: VPMOVZXWQ (R11), X11            // c44279341b
+       //TODO: VPMOVZXWQ X2, X11               // c4627934da
+       //TODO: VPMOVZXWQ X11, X11              // c4427934db
+       //TODO: VPMOVZXWQ (BX), Y2              // c4e27d3413
+       //TODO: VPMOVZXWQ (R11), Y2             // c4c27d3413
+       //TODO: VPMOVZXWQ X2, Y2                // c4e27d34d2
+       //TODO: VPMOVZXWQ X11, Y2               // c4c27d34d3
+       //TODO: VPMOVZXWQ (BX), Y11             // c4627d341b
+       //TODO: VPMOVZXWQ (R11), Y11            // c4427d341b
+       //TODO: VPMOVZXWQ X2, Y11               // c4627d34da
+       //TODO: VPMOVZXWQ X11, Y11              // c4427d34db
+       //TODO: VPMULDQ (BX), X9, X2            // c4e2312813
+       //TODO: VPMULDQ (R11), X9, X2           // c4c2312813
+       //TODO: VPMULDQ X2, X9, X2              // c4e23128d2
+       //TODO: VPMULDQ X11, X9, X2             // c4c23128d3
+       //TODO: VPMULDQ (BX), X9, X11           // c46231281b
+       //TODO: VPMULDQ (R11), X9, X11          // c44231281b
+       //TODO: VPMULDQ X2, X9, X11             // c4623128da
+       //TODO: VPMULDQ X11, X9, X11            // c4423128db
+       //TODO: VPMULDQ (BX), Y15, Y2           // c4e2052813
+       //TODO: VPMULDQ (R11), Y15, Y2          // c4c2052813
+       //TODO: VPMULDQ Y2, Y15, Y2             // c4e20528d2
+       //TODO: VPMULDQ Y11, Y15, Y2            // c4c20528d3
+       //TODO: VPMULDQ (BX), Y15, Y11          // c46205281b
+       //TODO: VPMULDQ (R11), Y15, Y11         // c44205281b
+       //TODO: VPMULDQ Y2, Y15, Y11            // c4620528da
+       //TODO: VPMULDQ Y11, Y15, Y11           // c4420528db
+       //TODO: VPMULHRSW (BX), X9, X2          // c4e2310b13
+       //TODO: VPMULHRSW (R11), X9, X2         // c4c2310b13
+       //TODO: VPMULHRSW X2, X9, X2            // c4e2310bd2
+       //TODO: VPMULHRSW X11, X9, X2           // c4c2310bd3
+       //TODO: VPMULHRSW (BX), X9, X11         // c462310b1b
+       //TODO: VPMULHRSW (R11), X9, X11        // c442310b1b
+       //TODO: VPMULHRSW X2, X9, X11           // c462310bda
+       //TODO: VPMULHRSW X11, X9, X11          // c442310bdb
+       //TODO: VPMULHRSW (BX), Y15, Y2         // c4e2050b13
+       //TODO: VPMULHRSW (R11), Y15, Y2        // c4c2050b13
+       //TODO: VPMULHRSW Y2, Y15, Y2           // c4e2050bd2
+       //TODO: VPMULHRSW Y11, Y15, Y2          // c4c2050bd3
+       //TODO: VPMULHRSW (BX), Y15, Y11        // c462050b1b
+       //TODO: VPMULHRSW (R11), Y15, Y11       // c442050b1b
+       //TODO: VPMULHRSW Y2, Y15, Y11          // c462050bda
+       //TODO: VPMULHRSW Y11, Y15, Y11         // c442050bdb
+       //TODO: VPMULHUW (BX), X9, X2           // c4e131e413 or c5b1e413
+       //TODO: VPMULHUW (R11), X9, X2          // c4c131e413
+       //TODO: VPMULHUW X2, X9, X2             // c4e131e4d2 or c5b1e4d2
+       //TODO: VPMULHUW X11, X9, X2            // c4c131e4d3
+       //TODO: VPMULHUW (BX), X9, X11          // c46131e41b or c531e41b
+       //TODO: VPMULHUW (R11), X9, X11         // c44131e41b
+       //TODO: VPMULHUW X2, X9, X11            // c46131e4da or c531e4da
+       //TODO: VPMULHUW X11, X9, X11           // c44131e4db
+       //TODO: VPMULHUW (BX), Y15, Y2          // c4e105e413 or c585e413
+       //TODO: VPMULHUW (R11), Y15, Y2         // c4c105e413
+       //TODO: VPMULHUW Y2, Y15, Y2            // c4e105e4d2 or c585e4d2
+       //TODO: VPMULHUW Y11, Y15, Y2           // c4c105e4d3
+       //TODO: VPMULHUW (BX), Y15, Y11         // c46105e41b or c505e41b
+       //TODO: VPMULHUW (R11), Y15, Y11        // c44105e41b
+       //TODO: VPMULHUW Y2, Y15, Y11           // c46105e4da or c505e4da
+       //TODO: VPMULHUW Y11, Y15, Y11          // c44105e4db
+       //TODO: VPMULHW (BX), X9, X2            // c4e131e513 or c5b1e513
+       //TODO: VPMULHW (R11), X9, X2           // c4c131e513
+       //TODO: VPMULHW X2, X9, X2              // c4e131e5d2 or c5b1e5d2
+       //TODO: VPMULHW X11, X9, X2             // c4c131e5d3
+       //TODO: VPMULHW (BX), X9, X11           // c46131e51b or c531e51b
+       //TODO: VPMULHW (R11), X9, X11          // c44131e51b
+       //TODO: VPMULHW X2, X9, X11             // c46131e5da or c531e5da
+       //TODO: VPMULHW X11, X9, X11            // c44131e5db
+       //TODO: VPMULHW (BX), Y15, Y2           // c4e105e513 or c585e513
+       //TODO: VPMULHW (R11), Y15, Y2          // c4c105e513
+       //TODO: VPMULHW Y2, Y15, Y2             // c4e105e5d2 or c585e5d2
+       //TODO: VPMULHW Y11, Y15, Y2            // c4c105e5d3
+       //TODO: VPMULHW (BX), Y15, Y11          // c46105e51b or c505e51b
+       //TODO: VPMULHW (R11), Y15, Y11         // c44105e51b
+       //TODO: VPMULHW Y2, Y15, Y11            // c46105e5da or c505e5da
+       //TODO: VPMULHW Y11, Y15, Y11           // c44105e5db
+       //TODO: VPMULLD (BX), X9, X2            // c4e2314013
+       //TODO: VPMULLD (R11), X9, X2           // c4c2314013
+       //TODO: VPMULLD X2, X9, X2              // c4e23140d2
+       //TODO: VPMULLD X11, X9, X2             // c4c23140d3
+       //TODO: VPMULLD (BX), X9, X11           // c46231401b
+       //TODO: VPMULLD (R11), X9, X11          // c44231401b
+       //TODO: VPMULLD X2, X9, X11             // c4623140da
+       //TODO: VPMULLD X11, X9, X11            // c4423140db
+       //TODO: VPMULLD (BX), Y15, Y2           // c4e2054013
+       //TODO: VPMULLD (R11), Y15, Y2          // c4c2054013
+       //TODO: VPMULLD Y2, Y15, Y2             // c4e20540d2
+       //TODO: VPMULLD Y11, Y15, Y2            // c4c20540d3
+       //TODO: VPMULLD (BX), Y15, Y11          // c46205401b
+       //TODO: VPMULLD (R11), Y15, Y11         // c44205401b
+       //TODO: VPMULLD Y2, Y15, Y11            // c4620540da
+       //TODO: VPMULLD Y11, Y15, Y11           // c4420540db
+       //TODO: VPMULLW (BX), X9, X2            // c4e131d513 or c5b1d513
+       //TODO: VPMULLW (R11), X9, X2           // c4c131d513
+       //TODO: VPMULLW X2, X9, X2              // c4e131d5d2 or c5b1d5d2
+       //TODO: VPMULLW X11, X9, X2             // c4c131d5d3
+       //TODO: VPMULLW (BX), X9, X11           // c46131d51b or c531d51b
+       //TODO: VPMULLW (R11), X9, X11          // c44131d51b
+       //TODO: VPMULLW X2, X9, X11             // c46131d5da or c531d5da
+       //TODO: VPMULLW X11, X9, X11            // c44131d5db
+       //TODO: VPMULLW (BX), Y15, Y2           // c4e105d513 or c585d513
+       //TODO: VPMULLW (R11), Y15, Y2          // c4c105d513
+       //TODO: VPMULLW Y2, Y15, Y2             // c4e105d5d2 or c585d5d2
+       //TODO: VPMULLW Y11, Y15, Y2            // c4c105d5d3
+       //TODO: VPMULLW (BX), Y15, Y11          // c46105d51b or c505d51b
+       //TODO: VPMULLW (R11), Y15, Y11         // c44105d51b
+       //TODO: VPMULLW Y2, Y15, Y11            // c46105d5da or c505d5da
+       //TODO: VPMULLW Y11, Y15, Y11           // c44105d5db
+       //TODO: VPMULUDQ (BX), X9, X2           // c4e131f413 or c5b1f413
+       //TODO: VPMULUDQ (R11), X9, X2          // c4c131f413
+       //TODO: VPMULUDQ X2, X9, X2             // c4e131f4d2 or c5b1f4d2
+       //TODO: VPMULUDQ X11, X9, X2            // c4c131f4d3
+       //TODO: VPMULUDQ (BX), X9, X11          // c46131f41b or c531f41b
+       //TODO: VPMULUDQ (R11), X9, X11         // c44131f41b
+       //TODO: VPMULUDQ X2, X9, X11            // c46131f4da or c531f4da
+       //TODO: VPMULUDQ X11, X9, X11           // c44131f4db
+       //TODO: VPMULUDQ (BX), Y15, Y2          // c4e105f413 or c585f413
+       //TODO: VPMULUDQ (R11), Y15, Y2         // c4c105f413
+       //TODO: VPMULUDQ Y2, Y15, Y2            // c4e105f4d2 or c585f4d2
+       //TODO: VPMULUDQ Y11, Y15, Y2           // c4c105f4d3
+       //TODO: VPMULUDQ (BX), Y15, Y11         // c46105f41b or c505f41b
+       //TODO: VPMULUDQ (R11), Y15, Y11        // c44105f41b
+       //TODO: VPMULUDQ Y2, Y15, Y11           // c46105f4da or c505f4da
+       //TODO: VPMULUDQ Y11, Y15, Y11          // c44105f4db
+       //TODO: VPOR (BX), X9, X2               // c4e131eb13 or c5b1eb13
+       //TODO: VPOR (R11), X9, X2              // c4c131eb13
+       //TODO: VPOR X2, X9, X2                 // c4e131ebd2 or c5b1ebd2
+       //TODO: VPOR X11, X9, X2                // c4c131ebd3
+       //TODO: VPOR (BX), X9, X11              // c46131eb1b or c531eb1b
+       //TODO: VPOR (R11), X9, X11             // c44131eb1b
+       //TODO: VPOR X2, X9, X11                // c46131ebda or c531ebda
+       //TODO: VPOR X11, X9, X11               // c44131ebdb
+       //TODO: VPOR (BX), Y15, Y2              // c4e105eb13 or c585eb13
+       //TODO: VPOR (R11), Y15, Y2             // c4c105eb13
+       //TODO: VPOR Y2, Y15, Y2                // c4e105ebd2 or c585ebd2
+       //TODO: VPOR Y11, Y15, Y2               // c4c105ebd3
+       //TODO: VPOR (BX), Y15, Y11             // c46105eb1b or c505eb1b
+       //TODO: VPOR (R11), Y15, Y11            // c44105eb1b
+       //TODO: VPOR Y2, Y15, Y11               // c46105ebda or c505ebda
+       //TODO: VPOR Y11, Y15, Y11              // c44105ebdb
+       //TODO: VPSADBW (BX), X9, X2            // c4e131f613 or c5b1f613
+       //TODO: VPSADBW (R11), X9, X2           // c4c131f613
+       //TODO: VPSADBW X2, X9, X2              // c4e131f6d2 or c5b1f6d2
+       //TODO: VPSADBW X11, X9, X2             // c4c131f6d3
+       //TODO: VPSADBW (BX), X9, X11           // c46131f61b or c531f61b
+       //TODO: VPSADBW (R11), X9, X11          // c44131f61b
+       //TODO: VPSADBW X2, X9, X11             // c46131f6da or c531f6da
+       //TODO: VPSADBW X11, X9, X11            // c44131f6db
+       //TODO: VPSADBW (BX), Y15, Y2           // c4e105f613 or c585f613
+       //TODO: VPSADBW (R11), Y15, Y2          // c4c105f613
+       //TODO: VPSADBW Y2, Y15, Y2             // c4e105f6d2 or c585f6d2
+       //TODO: VPSADBW Y11, Y15, Y2            // c4c105f6d3
+       //TODO: VPSADBW (BX), Y15, Y11          // c46105f61b or c505f61b
+       //TODO: VPSADBW (R11), Y15, Y11         // c44105f61b
+       //TODO: VPSADBW Y2, Y15, Y11            // c46105f6da or c505f6da
+       //TODO: VPSADBW Y11, Y15, Y11           // c44105f6db
+       //TODO: VPSHUFB (BX), X9, X2            // c4e2310013
+       //TODO: VPSHUFB (R11), X9, X2           // c4c2310013
+       //TODO: VPSHUFB X2, X9, X2              // c4e23100d2
+       //TODO: VPSHUFB X11, X9, X2             // c4c23100d3
+       //TODO: VPSHUFB (BX), X9, X11           // c46231001b
+       //TODO: VPSHUFB (R11), X9, X11          // c44231001b
+       //TODO: VPSHUFB X2, X9, X11             // c4623100da
+       //TODO: VPSHUFB X11, X9, X11            // c4423100db
+       //TODO: VPSHUFB (BX), Y15, Y2           // c4e2050013
+       //TODO: VPSHUFB (R11), Y15, Y2          // c4c2050013
+       //TODO: VPSHUFB Y2, Y15, Y2             // c4e20500d2
+       //TODO: VPSHUFB Y11, Y15, Y2            // c4c20500d3
+       //TODO: VPSHUFB (BX), Y15, Y11          // c46205001b
+       //TODO: VPSHUFB (R11), Y15, Y11         // c44205001b
+       //TODO: VPSHUFB Y2, Y15, Y11            // c4620500da
+       //TODO: VPSHUFB Y11, Y15, Y11           // c4420500db
+       //TODO: VPSHUFD $7, (BX), X2            // c4e179701307 or c5f9701307
+       //TODO: VPSHUFD $7, (R11), X2           // c4c179701307
+       //TODO: VPSHUFD $7, X2, X2              // c4e17970d207 or c5f970d207
+       //TODO: VPSHUFD $7, X11, X2             // c4c17970d307
+       //TODO: VPSHUFD $7, (BX), X11           // c46179701b07 or c579701b07
+       //TODO: VPSHUFD $7, (R11), X11          // c44179701b07
+       //TODO: VPSHUFD $7, X2, X11             // c4617970da07 or c57970da07
+       //TODO: VPSHUFD $7, X11, X11            // c4417970db07
+       //TODO: VPSHUFD $7, (BX), Y2            // c4e17d701307 or c5fd701307
+       //TODO: VPSHUFD $7, (R11), Y2           // c4c17d701307
+       //TODO: VPSHUFD $7, Y2, Y2              // c4e17d70d207 or c5fd70d207
+       //TODO: VPSHUFD $7, Y11, Y2             // c4c17d70d307
+       //TODO: VPSHUFD $7, (BX), Y11           // c4617d701b07 or c57d701b07
+       //TODO: VPSHUFD $7, (R11), Y11          // c4417d701b07
+       //TODO: VPSHUFD $7, Y2, Y11             // c4617d70da07 or c57d70da07
+       //TODO: VPSHUFD $7, Y11, Y11            // c4417d70db07
+       //TODO: VPSHUFHW $7, (BX), X2           // c4e17a701307 or c5fa701307
+       //TODO: VPSHUFHW $7, (R11), X2          // c4c17a701307
+       //TODO: VPSHUFHW $7, X2, X2             // c4e17a70d207 or c5fa70d207
+       //TODO: VPSHUFHW $7, X11, X2            // c4c17a70d307
+       //TODO: VPSHUFHW $7, (BX), X11          // c4617a701b07 or c57a701b07
+       //TODO: VPSHUFHW $7, (R11), X11         // c4417a701b07
+       //TODO: VPSHUFHW $7, X2, X11            // c4617a70da07 or c57a70da07
+       //TODO: VPSHUFHW $7, X11, X11           // c4417a70db07
+       //TODO: VPSHUFHW $7, (BX), Y2           // c4e17e701307 or c5fe701307
+       //TODO: VPSHUFHW $7, (R11), Y2          // c4c17e701307
+       //TODO: VPSHUFHW $7, Y2, Y2             // c4e17e70d207 or c5fe70d207
+       //TODO: VPSHUFHW $7, Y11, Y2            // c4c17e70d307
+       //TODO: VPSHUFHW $7, (BX), Y11          // c4617e701b07 or c57e701b07
+       //TODO: VPSHUFHW $7, (R11), Y11         // c4417e701b07
+       //TODO: VPSHUFHW $7, Y2, Y11            // c4617e70da07 or c57e70da07
+       //TODO: VPSHUFHW $7, Y11, Y11           // c4417e70db07
+       //TODO: VPSHUFLW $7, (BX), X2           // c4e17b701307 or c5fb701307
+       //TODO: VPSHUFLW $7, (R11), X2          // c4c17b701307
+       //TODO: VPSHUFLW $7, X2, X2             // c4e17b70d207 or c5fb70d207
+       //TODO: VPSHUFLW $7, X11, X2            // c4c17b70d307
+       //TODO: VPSHUFLW $7, (BX), X11          // c4617b701b07 or c57b701b07
+       //TODO: VPSHUFLW $7, (R11), X11         // c4417b701b07
+       //TODO: VPSHUFLW $7, X2, X11            // c4617b70da07 or c57b70da07
+       //TODO: VPSHUFLW $7, X11, X11           // c4417b70db07
+       //TODO: VPSHUFLW $7, (BX), Y2           // c4e17f701307 or c5ff701307
+       //TODO: VPSHUFLW $7, (R11), Y2          // c4c17f701307
+       //TODO: VPSHUFLW $7, Y2, Y2             // c4e17f70d207 or c5ff70d207
+       //TODO: VPSHUFLW $7, Y11, Y2            // c4c17f70d307
+       //TODO: VPSHUFLW $7, (BX), Y11          // c4617f701b07 or c57f701b07
+       //TODO: VPSHUFLW $7, (R11), Y11         // c4417f701b07
+       //TODO: VPSHUFLW $7, Y2, Y11            // c4617f70da07 or c57f70da07
+       //TODO: VPSHUFLW $7, Y11, Y11           // c4417f70db07
+       //TODO: VPSIGNB (BX), X9, X2            // c4e2310813
+       //TODO: VPSIGNB (R11), X9, X2           // c4c2310813
+       //TODO: VPSIGNB X2, X9, X2              // c4e23108d2
+       //TODO: VPSIGNB X11, X9, X2             // c4c23108d3
+       //TODO: VPSIGNB (BX), X9, X11           // c46231081b
+       //TODO: VPSIGNB (R11), X9, X11          // c44231081b
+       //TODO: VPSIGNB X2, X9, X11             // c4623108da
+       //TODO: VPSIGNB X11, X9, X11            // c4423108db
+       //TODO: VPSIGNB (BX), Y15, Y2           // c4e2050813
+       //TODO: VPSIGNB (R11), Y15, Y2          // c4c2050813
+       //TODO: VPSIGNB Y2, Y15, Y2             // c4e20508d2
+       //TODO: VPSIGNB Y11, Y15, Y2            // c4c20508d3
+       //TODO: VPSIGNB (BX), Y15, Y11          // c46205081b
+       //TODO: VPSIGNB (R11), Y15, Y11         // c44205081b
+       //TODO: VPSIGNB Y2, Y15, Y11            // c4620508da
+       //TODO: VPSIGNB Y11, Y15, Y11           // c4420508db
+       //TODO: VPSIGND (BX), X9, X2            // c4e2310a13
+       //TODO: VPSIGND (R11), X9, X2           // c4c2310a13
+       //TODO: VPSIGND X2, X9, X2              // c4e2310ad2
+       //TODO: VPSIGND X11, X9, X2             // c4c2310ad3
+       //TODO: VPSIGND (BX), X9, X11           // c462310a1b
+       //TODO: VPSIGND (R11), X9, X11          // c442310a1b
+       //TODO: VPSIGND X2, X9, X11             // c462310ada
+       //TODO: VPSIGND X11, X9, X11            // c442310adb
+       //TODO: VPSIGND (BX), Y15, Y2           // c4e2050a13
+       //TODO: VPSIGND (R11), Y15, Y2          // c4c2050a13
+       //TODO: VPSIGND Y2, Y15, Y2             // c4e2050ad2
+       //TODO: VPSIGND Y11, Y15, Y2            // c4c2050ad3
+       //TODO: VPSIGND (BX), Y15, Y11          // c462050a1b
+       //TODO: VPSIGND (R11), Y15, Y11         // c442050a1b
+       //TODO: VPSIGND Y2, Y15, Y11            // c462050ada
+       //TODO: VPSIGND Y11, Y15, Y11           // c442050adb
+       //TODO: VPSIGNW (BX), X9, X2            // c4e2310913
+       //TODO: VPSIGNW (R11), X9, X2           // c4c2310913
+       //TODO: VPSIGNW X2, X9, X2              // c4e23109d2
+       //TODO: VPSIGNW X11, X9, X2             // c4c23109d3
+       //TODO: VPSIGNW (BX), X9, X11           // c46231091b
+       //TODO: VPSIGNW (R11), X9, X11          // c44231091b
+       //TODO: VPSIGNW X2, X9, X11             // c4623109da
+       //TODO: VPSIGNW X11, X9, X11            // c4423109db
+       //TODO: VPSIGNW (BX), Y15, Y2           // c4e2050913
+       //TODO: VPSIGNW (R11), Y15, Y2          // c4c2050913
+       //TODO: VPSIGNW Y2, Y15, Y2             // c4e20509d2
+       //TODO: VPSIGNW Y11, Y15, Y2            // c4c20509d3
+       //TODO: VPSIGNW (BX), Y15, Y11          // c46205091b
+       //TODO: VPSIGNW (R11), Y15, Y11         // c44205091b
+       //TODO: VPSIGNW Y2, Y15, Y11            // c4620509da
+       //TODO: VPSIGNW Y11, Y15, Y11           // c4420509db
+       //TODO: VPSLLD (BX), X9, X2             // c4e131f213 or c5b1f213
+       //TODO: VPSLLD (R11), X9, X2            // c4c131f213
+       //TODO: VPSLLD X2, X9, X2               // c4e131f2d2 or c5b1f2d2
+       //TODO: VPSLLD X11, X9, X2              // c4c131f2d3
+       //TODO: VPSLLD (BX), X9, X11            // c46131f21b or c531f21b
+       //TODO: VPSLLD (R11), X9, X11           // c44131f21b
+       //TODO: VPSLLD X2, X9, X11              // c46131f2da or c531f2da
+       //TODO: VPSLLD X11, X9, X11             // c44131f2db
+       //TODO: VPSLLD $7, X2, X9               // c4e13172f207 or c5b172f207
+       //TODO: VPSLLD $7, X11, X9              // c4c13172f307
+       //TODO: VPSLLDQ $7, X2, X9              // c4e13173fa07 or c5b173fa07
+       //TODO: VPSLLDQ $7, X11, X9             // c4c13173fb07
+       //TODO: VPSLLDQ $7, Y2, Y15             // c4e10573fa07 or c58573fa07
+       //TODO: VPSLLDQ $7, Y11, Y15            // c4c10573fb07
+       //TODO: VPSLLQ (BX), X9, X2             // c4e131f313 or c5b1f313
+       //TODO: VPSLLQ (R11), X9, X2            // c4c131f313
+       //TODO: VPSLLQ X2, X9, X2               // c4e131f3d2 or c5b1f3d2
+       //TODO: VPSLLQ X11, X9, X2              // c4c131f3d3
+       //TODO: VPSLLQ (BX), X9, X11            // c46131f31b or c531f31b
+       //TODO: VPSLLQ (R11), X9, X11           // c44131f31b
+       //TODO: VPSLLQ X2, X9, X11              // c46131f3da or c531f3da
+       //TODO: VPSLLQ X11, X9, X11             // c44131f3db
+       //TODO: VPSLLQ $7, X2, X9               // c4e13173f207 or c5b173f207
+       //TODO: VPSLLQ $7, X11, X9              // c4c13173f307
+       //TODO: VPSLLVD (BX), X9, X2            // c4e2314713
+       //TODO: VPSLLVD (R11), X9, X2           // c4c2314713
+       //TODO: VPSLLVD X2, X9, X2              // c4e23147d2
+       //TODO: VPSLLVD X11, X9, X2             // c4c23147d3
+       //TODO: VPSLLVD (BX), X9, X11           // c46231471b
+       //TODO: VPSLLVD (R11), X9, X11          // c44231471b
+       //TODO: VPSLLVD X2, X9, X11             // c4623147da
+       //TODO: VPSLLVD X11, X9, X11            // c4423147db
+       //TODO: VPSLLVD (BX), Y15, Y2           // c4e2054713
+       //TODO: VPSLLVD (R11), Y15, Y2          // c4c2054713
+       //TODO: VPSLLVD Y2, Y15, Y2             // c4e20547d2
+       //TODO: VPSLLVD Y11, Y15, Y2            // c4c20547d3
+       //TODO: VPSLLVD (BX), Y15, Y11          // c46205471b
+       //TODO: VPSLLVD (R11), Y15, Y11         // c44205471b
+       //TODO: VPSLLVD Y2, Y15, Y11            // c4620547da
+       //TODO: VPSLLVD Y11, Y15, Y11           // c4420547db
+       //TODO: VPSLLVQ (BX), X9, X2            // c4e2b14713
+       //TODO: VPSLLVQ (R11), X9, X2           // c4c2b14713
+       //TODO: VPSLLVQ X2, X9, X2              // c4e2b147d2
+       //TODO: VPSLLVQ X11, X9, X2             // c4c2b147d3
+       //TODO: VPSLLVQ (BX), X9, X11           // c462b1471b
+       //TODO: VPSLLVQ (R11), X9, X11          // c442b1471b
+       //TODO: VPSLLVQ X2, X9, X11             // c462b147da
+       //TODO: VPSLLVQ X11, X9, X11            // c442b147db
+       //TODO: VPSLLVQ (BX), Y15, Y2           // c4e2854713
+       //TODO: VPSLLVQ (R11), Y15, Y2          // c4c2854713
+       //TODO: VPSLLVQ Y2, Y15, Y2             // c4e28547d2
+       //TODO: VPSLLVQ Y11, Y15, Y2            // c4c28547d3
+       //TODO: VPSLLVQ (BX), Y15, Y11          // c46285471b
+       //TODO: VPSLLVQ (R11), Y15, Y11         // c44285471b
+       //TODO: VPSLLVQ Y2, Y15, Y11            // c4628547da
+       //TODO: VPSLLVQ Y11, Y15, Y11           // c4428547db
+       //TODO: VPSLLW (BX), X9, X2             // c4e131f113 or c5b1f113
+       //TODO: VPSLLW (R11), X9, X2            // c4c131f113
+       //TODO: VPSLLW X2, X9, X2               // c4e131f1d2 or c5b1f1d2
+       //TODO: VPSLLW X11, X9, X2              // c4c131f1d3
+       //TODO: VPSLLW (BX), X9, X11            // c46131f11b or c531f11b
+       //TODO: VPSLLW (R11), X9, X11           // c44131f11b
+       //TODO: VPSLLW X2, X9, X11              // c46131f1da or c531f1da
+       //TODO: VPSLLW X11, X9, X11             // c44131f1db
+       //TODO: VPSLLW $7, X2, X9               // c4e13171f207 or c5b171f207
+       //TODO: VPSLLW $7, X11, X9              // c4c13171f307
+       //TODO: VPSLLW (BX), Y15, Y2            // c4e105f113 or c585f113
+       //TODO: VPSLLW (R11), Y15, Y2           // c4c105f113
+       //TODO: VPSLLW X2, Y15, Y2              // c4e105f1d2 or c585f1d2
+       //TODO: VPSLLW X11, Y15, Y2             // c4c105f1d3
+       //TODO: VPSLLW (BX), Y15, Y11           // c46105f11b or c505f11b
+       //TODO: VPSLLW (R11), Y15, Y11          // c44105f11b
+       //TODO: VPSLLW X2, Y15, Y11             // c46105f1da or c505f1da
+       //TODO: VPSLLW X11, Y15, Y11            // c44105f1db
+       //TODO: VPSLLW $7, Y2, Y15              // c4e10571f207 or c58571f207
+       //TODO: VPSLLW $7, Y11, Y15             // c4c10571f307
+       //TODO: VPSRAD (BX), X9, X2             // c4e131e213 or c5b1e213
+       //TODO: VPSRAD (R11), X9, X2            // c4c131e213
+       //TODO: VPSRAD X2, X9, X2               // c4e131e2d2 or c5b1e2d2
+       //TODO: VPSRAD X11, X9, X2              // c4c131e2d3
+       //TODO: VPSRAD (BX), X9, X11            // c46131e21b or c531e21b
+       //TODO: VPSRAD (R11), X9, X11           // c44131e21b
+       //TODO: VPSRAD X2, X9, X11              // c46131e2da or c531e2da
+       //TODO: VPSRAD X11, X9, X11             // c44131e2db
+       //TODO: VPSRAD $7, X2, X9               // c4e13172e207 or c5b172e207
+       //TODO: VPSRAD $7, X11, X9              // c4c13172e307
+       //TODO: VPSRAD (BX), Y15, Y2            // c4e105e213 or c585e213
+       //TODO: VPSRAD (R11), Y15, Y2           // c4c105e213
+       //TODO: VPSRAD X2, Y15, Y2              // c4e105e2d2 or c585e2d2
+       //TODO: VPSRAD X11, Y15, Y2             // c4c105e2d3
+       //TODO: VPSRAD (BX), Y15, Y11           // c46105e21b or c505e21b
+       //TODO: VPSRAD (R11), Y15, Y11          // c44105e21b
+       //TODO: VPSRAD X2, Y15, Y11             // c46105e2da or c505e2da
+       //TODO: VPSRAD X11, Y15, Y11            // c44105e2db
+       //TODO: VPSRAD $7, Y2, Y15              // c4e10572e207 or c58572e207
+       //TODO: VPSRAD $7, Y11, Y15             // c4c10572e307
+       //TODO: VPSRAVD (BX), X9, X2            // c4e2314613
+       //TODO: VPSRAVD (R11), X9, X2           // c4c2314613
+       //TODO: VPSRAVD X2, X9, X2              // c4e23146d2
+       //TODO: VPSRAVD X11, X9, X2             // c4c23146d3
+       //TODO: VPSRAVD (BX), X9, X11           // c46231461b
+       //TODO: VPSRAVD (R11), X9, X11          // c44231461b
+       //TODO: VPSRAVD X2, X9, X11             // c4623146da
+       //TODO: VPSRAVD X11, X9, X11            // c4423146db
+       //TODO: VPSRAVD (BX), Y15, Y2           // c4e2054613
+       //TODO: VPSRAVD (R11), Y15, Y2          // c4c2054613
+       //TODO: VPSRAVD Y2, Y15, Y2             // c4e20546d2
+       //TODO: VPSRAVD Y11, Y15, Y2            // c4c20546d3
+       //TODO: VPSRAVD (BX), Y15, Y11          // c46205461b
+       //TODO: VPSRAVD (R11), Y15, Y11         // c44205461b
+       //TODO: VPSRAVD Y2, Y15, Y11            // c4620546da
+       //TODO: VPSRAVD Y11, Y15, Y11           // c4420546db
+       //TODO: VPSRAW (BX), X9, X2             // c4e131e113 or c5b1e113
+       //TODO: VPSRAW (R11), X9, X2            // c4c131e113
+       //TODO: VPSRAW X2, X9, X2               // c4e131e1d2 or c5b1e1d2
+       //TODO: VPSRAW X11, X9, X2              // c4c131e1d3
+       //TODO: VPSRAW (BX), X9, X11            // c46131e11b or c531e11b
+       //TODO: VPSRAW (R11), X9, X11           // c44131e11b
+       //TODO: VPSRAW X2, X9, X11              // c46131e1da or c531e1da
+       //TODO: VPSRAW X11, X9, X11             // c44131e1db
+       //TODO: VPSRAW $7, X2, X9               // c4e13171e207 or c5b171e207
+       //TODO: VPSRAW $7, X11, X9              // c4c13171e307
+       //TODO: VPSRAW (BX), Y15, Y2            // c4e105e113 or c585e113
+       //TODO: VPSRAW (R11), Y15, Y2           // c4c105e113
+       //TODO: VPSRAW X2, Y15, Y2              // c4e105e1d2 or c585e1d2
+       //TODO: VPSRAW X11, Y15, Y2             // c4c105e1d3
+       //TODO: VPSRAW (BX), Y15, Y11           // c46105e11b or c505e11b
+       //TODO: VPSRAW (R11), Y15, Y11          // c44105e11b
+       //TODO: VPSRAW X2, Y15, Y11             // c46105e1da or c505e1da
+       //TODO: VPSRAW X11, Y15, Y11            // c44105e1db
+       //TODO: VPSRAW $7, Y2, Y15              // c4e10571e207 or c58571e207
+       //TODO: VPSRAW $7, Y11, Y15             // c4c10571e307
+       //TODO: VPSRLD (BX), X9, X2             // c4e131d213 or c5b1d213
+       //TODO: VPSRLD (R11), X9, X2            // c4c131d213
+       //TODO: VPSRLD X2, X9, X2               // c4e131d2d2 or c5b1d2d2
+       //TODO: VPSRLD X11, X9, X2              // c4c131d2d3
+       //TODO: VPSRLD (BX), X9, X11            // c46131d21b or c531d21b
+       //TODO: VPSRLD (R11), X9, X11           // c44131d21b
+       //TODO: VPSRLD X2, X9, X11              // c46131d2da or c531d2da
+       //TODO: VPSRLD X11, X9, X11             // c44131d2db
+       //TODO: VPSRLD $7, X2, X9               // c4e13172d207 or c5b172d207
+       //TODO: VPSRLD $7, X11, X9              // c4c13172d307
+       //TODO: VPSRLDQ $7, X2, X9              // c4e13173da07 or c5b173da07
+       //TODO: VPSRLDQ $7, X11, X9             // c4c13173db07
+       //TODO: VPSRLDQ $7, Y2, Y15             // c4e10573da07 or c58573da07
+       //TODO: VPSRLDQ $7, Y11, Y15            // c4c10573db07
+       //TODO: VPSRLQ (BX), X9, X2             // c4e131d313 or c5b1d313
+       //TODO: VPSRLQ (R11), X9, X2            // c4c131d313
+       //TODO: VPSRLQ X2, X9, X2               // c4e131d3d2 or c5b1d3d2
+       //TODO: VPSRLQ X11, X9, X2              // c4c131d3d3
+       //TODO: VPSRLQ (BX), X9, X11            // c46131d31b or c531d31b
+       //TODO: VPSRLQ (R11), X9, X11           // c44131d31b
+       //TODO: VPSRLQ X2, X9, X11              // c46131d3da or c531d3da
+       //TODO: VPSRLQ X11, X9, X11             // c44131d3db
+       //TODO: VPSRLQ $7, X2, X9               // c4e13173d207 or c5b173d207
+       //TODO: VPSRLQ $7, X11, X9              // c4c13173d307
+       //TODO: VPSRLVD (BX), X9, X2            // c4e2314513
+       //TODO: VPSRLVD (R11), X9, X2           // c4c2314513
+       //TODO: VPSRLVD X2, X9, X2              // c4e23145d2
+       //TODO: VPSRLVD X11, X9, X2             // c4c23145d3
+       //TODO: VPSRLVD (BX), X9, X11           // c46231451b
+       //TODO: VPSRLVD (R11), X9, X11          // c44231451b
+       //TODO: VPSRLVD X2, X9, X11             // c4623145da
+       //TODO: VPSRLVD X11, X9, X11            // c4423145db
+       //TODO: VPSRLVD (BX), Y15, Y2           // c4e2054513
+       //TODO: VPSRLVD (R11), Y15, Y2          // c4c2054513
+       //TODO: VPSRLVD Y2, Y15, Y2             // c4e20545d2
+       //TODO: VPSRLVD Y11, Y15, Y2            // c4c20545d3
+       //TODO: VPSRLVD (BX), Y15, Y11          // c46205451b
+       //TODO: VPSRLVD (R11), Y15, Y11         // c44205451b
+       //TODO: VPSRLVD Y2, Y15, Y11            // c4620545da
+       //TODO: VPSRLVD Y11, Y15, Y11           // c4420545db
+       //TODO: VPSRLVQ (BX), X9, X2            // c4e2b14513
+       //TODO: VPSRLVQ (R11), X9, X2           // c4c2b14513
+       //TODO: VPSRLVQ X2, X9, X2              // c4e2b145d2
+       //TODO: VPSRLVQ X11, X9, X2             // c4c2b145d3
+       //TODO: VPSRLVQ (BX), X9, X11           // c462b1451b
+       //TODO: VPSRLVQ (R11), X9, X11          // c442b1451b
+       //TODO: VPSRLVQ X2, X9, X11             // c462b145da
+       //TODO: VPSRLVQ X11, X9, X11            // c442b145db
+       //TODO: VPSRLVQ (BX), Y15, Y2           // c4e2854513
+       //TODO: VPSRLVQ (R11), Y15, Y2          // c4c2854513
+       //TODO: VPSRLVQ Y2, Y15, Y2             // c4e28545d2
+       //TODO: VPSRLVQ Y11, Y15, Y2            // c4c28545d3
+       //TODO: VPSRLVQ (BX), Y15, Y11          // c46285451b
+       //TODO: VPSRLVQ (R11), Y15, Y11         // c44285451b
+       //TODO: VPSRLVQ Y2, Y15, Y11            // c4628545da
+       //TODO: VPSRLVQ Y11, Y15, Y11           // c4428545db
+       //TODO: VPSRLW (BX), X9, X2             // c4e131d113 or c5b1d113
+       //TODO: VPSRLW (R11), X9, X2            // c4c131d113
+       //TODO: VPSRLW X2, X9, X2               // c4e131d1d2 or c5b1d1d2
+       //TODO: VPSRLW X11, X9, X2              // c4c131d1d3
+       //TODO: VPSRLW (BX), X9, X11            // c46131d11b or c531d11b
+       //TODO: VPSRLW (R11), X9, X11           // c44131d11b
+       //TODO: VPSRLW X2, X9, X11              // c46131d1da or c531d1da
+       //TODO: VPSRLW X11, X9, X11             // c44131d1db
+       //TODO: VPSRLW $7, X2, X9               // c4e13171d207 or c5b171d207
+       //TODO: VPSRLW $7, X11, X9              // c4c13171d307
+       //TODO: VPSRLW (BX), Y15, Y2            // c4e105d113 or c585d113
+       //TODO: VPSRLW (R11), Y15, Y2           // c4c105d113
+       //TODO: VPSRLW X2, Y15, Y2              // c4e105d1d2 or c585d1d2
+       //TODO: VPSRLW X11, Y15, Y2             // c4c105d1d3
+       //TODO: VPSRLW (BX), Y15, Y11           // c46105d11b or c505d11b
+       //TODO: VPSRLW (R11), Y15, Y11          // c44105d11b
+       //TODO: VPSRLW X2, Y15, Y11             // c46105d1da or c505d1da
+       //TODO: VPSRLW X11, Y15, Y11            // c44105d1db
+       //TODO: VPSRLW $7, Y2, Y15              // c4e10571d207 or c58571d207
+       //TODO: VPSRLW $7, Y11, Y15             // c4c10571d307
+       //TODO: VPSUBB (BX), X9, X2             // c4e131f813 or c5b1f813
+       //TODO: VPSUBB (R11), X9, X2            // c4c131f813
+       //TODO: VPSUBB X2, X9, X2               // c4e131f8d2 or c5b1f8d2
+       //TODO: VPSUBB X11, X9, X2              // c4c131f8d3
+       //TODO: VPSUBB (BX), X9, X11            // c46131f81b or c531f81b
+       //TODO: VPSUBB (R11), X9, X11           // c44131f81b
+       //TODO: VPSUBB X2, X9, X11              // c46131f8da or c531f8da
+       //TODO: VPSUBB X11, X9, X11             // c44131f8db
+       //TODO: VPSUBB (BX), Y15, Y2            // c4e105f813 or c585f813
+       //TODO: VPSUBB (R11), Y15, Y2           // c4c105f813
+       //TODO: VPSUBB Y2, Y15, Y2              // c4e105f8d2 or c585f8d2
+       //TODO: VPSUBB Y11, Y15, Y2             // c4c105f8d3
+       //TODO: VPSUBB (BX), Y15, Y11           // c46105f81b or c505f81b
+       //TODO: VPSUBB (R11), Y15, Y11          // c44105f81b
+       //TODO: VPSUBB Y2, Y15, Y11             // c46105f8da or c505f8da
+       //TODO: VPSUBB Y11, Y15, Y11            // c44105f8db
+       //TODO: VPSUBD (BX), X9, X2             // c4e131fa13 or c5b1fa13
+       //TODO: VPSUBD (R11), X9, X2            // c4c131fa13
+       //TODO: VPSUBD X2, X9, X2               // c4e131fad2 or c5b1fad2
+       //TODO: VPSUBD X11, X9, X2              // c4c131fad3
+       //TODO: VPSUBD (BX), X9, X11            // c46131fa1b or c531fa1b
+       //TODO: VPSUBD (R11), X9, X11           // c44131fa1b
+       //TODO: VPSUBD X2, X9, X11              // c46131fada or c531fada
+       //TODO: VPSUBD X11, X9, X11             // c44131fadb
+       //TODO: VPSUBD (BX), Y15, Y2            // c4e105fa13 or c585fa13
+       //TODO: VPSUBD (R11), Y15, Y2           // c4c105fa13
+       //TODO: VPSUBD Y2, Y15, Y2              // c4e105fad2 or c585fad2
+       //TODO: VPSUBD Y11, Y15, Y2             // c4c105fad3
+       //TODO: VPSUBD (BX), Y15, Y11           // c46105fa1b or c505fa1b
+       //TODO: VPSUBD (R11), Y15, Y11          // c44105fa1b
+       //TODO: VPSUBD Y2, Y15, Y11             // c46105fada or c505fada
+       //TODO: VPSUBD Y11, Y15, Y11            // c44105fadb
+       //TODO: VPSUBQ (BX), X9, X2             // c4e131fb13 or c5b1fb13
+       //TODO: VPSUBQ (R11), X9, X2            // c4c131fb13
+       //TODO: VPSUBQ X2, X9, X2               // c4e131fbd2 or c5b1fbd2
+       //TODO: VPSUBQ X11, X9, X2              // c4c131fbd3
+       //TODO: VPSUBQ (BX), X9, X11            // c46131fb1b or c531fb1b
+       //TODO: VPSUBQ (R11), X9, X11           // c44131fb1b
+       //TODO: VPSUBQ X2, X9, X11              // c46131fbda or c531fbda
+       //TODO: VPSUBQ X11, X9, X11             // c44131fbdb
+       //TODO: VPSUBQ (BX), Y15, Y2            // c4e105fb13 or c585fb13
+       //TODO: VPSUBQ (R11), Y15, Y2           // c4c105fb13
+       //TODO: VPSUBQ Y2, Y15, Y2              // c4e105fbd2 or c585fbd2
+       //TODO: VPSUBQ Y11, Y15, Y2             // c4c105fbd3
+       //TODO: VPSUBQ (BX), Y15, Y11           // c46105fb1b or c505fb1b
+       //TODO: VPSUBQ (R11), Y15, Y11          // c44105fb1b
+       //TODO: VPSUBQ Y2, Y15, Y11             // c46105fbda or c505fbda
+       //TODO: VPSUBQ Y11, Y15, Y11            // c44105fbdb
+       //TODO: VPSUBSB (BX), X9, X2            // c4e131e813 or c5b1e813
+       //TODO: VPSUBSB (R11), X9, X2           // c4c131e813
+       //TODO: VPSUBSB X2, X9, X2              // c4e131e8d2 or c5b1e8d2
+       //TODO: VPSUBSB X11, X9, X2             // c4c131e8d3
+       //TODO: VPSUBSB (BX), X9, X11           // c46131e81b or c531e81b
+       //TODO: VPSUBSB (R11), X9, X11          // c44131e81b
+       //TODO: VPSUBSB X2, X9, X11             // c46131e8da or c531e8da
+       //TODO: VPSUBSB X11, X9, X11            // c44131e8db
+       //TODO: VPSUBSB (BX), Y15, Y2           // c4e105e813 or c585e813
+       //TODO: VPSUBSB (R11), Y15, Y2          // c4c105e813
+       //TODO: VPSUBSB Y2, Y15, Y2             // c4e105e8d2 or c585e8d2
+       //TODO: VPSUBSB Y11, Y15, Y2            // c4c105e8d3
+       //TODO: VPSUBSB (BX), Y15, Y11          // c46105e81b or c505e81b
+       //TODO: VPSUBSB (R11), Y15, Y11         // c44105e81b
+       //TODO: VPSUBSB Y2, Y15, Y11            // c46105e8da or c505e8da
+       //TODO: VPSUBSB Y11, Y15, Y11           // c44105e8db
+       //TODO: VPSUBSW (BX), X9, X2            // c4e131e913 or c5b1e913
+       //TODO: VPSUBSW (R11), X9, X2           // c4c131e913
+       //TODO: VPSUBSW X2, X9, X2              // c4e131e9d2 or c5b1e9d2
+       //TODO: VPSUBSW X11, X9, X2             // c4c131e9d3
+       //TODO: VPSUBSW (BX), X9, X11           // c46131e91b or c531e91b
+       //TODO: VPSUBSW (R11), X9, X11          // c44131e91b
+       //TODO: VPSUBSW X2, X9, X11             // c46131e9da or c531e9da
+       //TODO: VPSUBSW X11, X9, X11            // c44131e9db
+       //TODO: VPSUBSW (BX), Y15, Y2           // c4e105e913 or c585e913
+       //TODO: VPSUBSW (R11), Y15, Y2          // c4c105e913
+       //TODO: VPSUBSW Y2, Y15, Y2             // c4e105e9d2 or c585e9d2
+       //TODO: VPSUBSW Y11, Y15, Y2            // c4c105e9d3
+       //TODO: VPSUBSW (BX), Y15, Y11          // c46105e91b or c505e91b
+       //TODO: VPSUBSW (R11), Y15, Y11         // c44105e91b
+       //TODO: VPSUBSW Y2, Y15, Y11            // c46105e9da or c505e9da
+       //TODO: VPSUBSW Y11, Y15, Y11           // c44105e9db
+       //TODO: VPSUBUSB (BX), X9, X2           // c4e131d813 or c5b1d813
+       //TODO: VPSUBUSB (R11), X9, X2          // c4c131d813
+       //TODO: VPSUBUSB X2, X9, X2             // c4e131d8d2 or c5b1d8d2
+       //TODO: VPSUBUSB X11, X9, X2            // c4c131d8d3
+       //TODO: VPSUBUSB (BX), X9, X11          // c46131d81b or c531d81b
+       //TODO: VPSUBUSB (R11), X9, X11         // c44131d81b
+       //TODO: VPSUBUSB X2, X9, X11            // c46131d8da or c531d8da
+       //TODO: VPSUBUSB X11, X9, X11           // c44131d8db
+       //TODO: VPSUBUSB (BX), Y15, Y2          // c4e105d813 or c585d813
+       //TODO: VPSUBUSB (R11), Y15, Y2         // c4c105d813
+       //TODO: VPSUBUSB Y2, Y15, Y2            // c4e105d8d2 or c585d8d2
+       //TODO: VPSUBUSB Y11, Y15, Y2           // c4c105d8d3
+       //TODO: VPSUBUSB (BX), Y15, Y11         // c46105d81b or c505d81b
+       //TODO: VPSUBUSB (R11), Y15, Y11        // c44105d81b
+       //TODO: VPSUBUSB Y2, Y15, Y11           // c46105d8da or c505d8da
+       //TODO: VPSUBUSB Y11, Y15, Y11          // c44105d8db
+       //TODO: VPSUBUSW (BX), X9, X2           // c4e131d913 or c5b1d913
+       //TODO: VPSUBUSW (R11), X9, X2          // c4c131d913
+       //TODO: VPSUBUSW X2, X9, X2             // c4e131d9d2 or c5b1d9d2
+       //TODO: VPSUBUSW X11, X9, X2            // c4c131d9d3
+       //TODO: VPSUBUSW (BX), X9, X11          // c46131d91b or c531d91b
+       //TODO: VPSUBUSW (R11), X9, X11         // c44131d91b
+       //TODO: VPSUBUSW X2, X9, X11            // c46131d9da or c531d9da
+       //TODO: VPSUBUSW X11, X9, X11           // c44131d9db
+       //TODO: VPSUBUSW (BX), Y15, Y2          // c4e105d913 or c585d913
+       //TODO: VPSUBUSW (R11), Y15, Y2         // c4c105d913
+       //TODO: VPSUBUSW Y2, Y15, Y2            // c4e105d9d2 or c585d9d2
+       //TODO: VPSUBUSW Y11, Y15, Y2           // c4c105d9d3
+       //TODO: VPSUBUSW (BX), Y15, Y11         // c46105d91b or c505d91b
+       //TODO: VPSUBUSW (R11), Y15, Y11        // c44105d91b
+       //TODO: VPSUBUSW Y2, Y15, Y11           // c46105d9da or c505d9da
+       //TODO: VPSUBUSW Y11, Y15, Y11          // c44105d9db
+       //TODO: VPSUBW (BX), X9, X2             // c4e131f913 or c5b1f913
+       //TODO: VPSUBW (R11), X9, X2            // c4c131f913
+       //TODO: VPSUBW X2, X9, X2               // c4e131f9d2 or c5b1f9d2
+       //TODO: VPSUBW X11, X9, X2              // c4c131f9d3
+       //TODO: VPSUBW (BX), X9, X11            // c46131f91b or c531f91b
+       //TODO: VPSUBW (R11), X9, X11           // c44131f91b
+       //TODO: VPSUBW X2, X9, X11              // c46131f9da or c531f9da
+       //TODO: VPSUBW X11, X9, X11             // c44131f9db
+       //TODO: VPSUBW (BX), Y15, Y2            // c4e105f913 or c585f913
+       //TODO: VPSUBW (R11), Y15, Y2           // c4c105f913
+       //TODO: VPSUBW Y2, Y15, Y2              // c4e105f9d2 or c585f9d2
+       //TODO: VPSUBW Y11, Y15, Y2             // c4c105f9d3
+       //TODO: VPSUBW (BX), Y15, Y11           // c46105f91b or c505f91b
+       //TODO: VPSUBW (R11), Y15, Y11          // c44105f91b
+       //TODO: VPSUBW Y2, Y15, Y11             // c46105f9da or c505f9da
+       //TODO: VPSUBW Y11, Y15, Y11            // c44105f9db
+       VPTEST (BX), X2                         // c4e2791713
+       VPTEST (R11), X2                        // c4c2791713
+       VPTEST X2, X2                           // c4e27917d2
+       VPTEST X11, X2                          // c4c27917d3
+       VPTEST (BX), X11                        // c46279171b
+       VPTEST (R11), X11                       // c44279171b
+       VPTEST X2, X11                          // c4627917da
+       VPTEST X11, X11                         // c4427917db
+       VPTEST (BX), Y2                         // c4e27d1713
+       VPTEST (R11), Y2                        // c4c27d1713
+       VPTEST Y2, Y2                           // c4e27d17d2
+       VPTEST Y11, Y2                          // c4c27d17d3
+       VPTEST (BX), Y11                        // c4627d171b
+       VPTEST (R11), Y11                       // c4427d171b
+       VPTEST Y2, Y11                          // c4627d17da
+       VPTEST Y11, Y11                         // c4427d17db
+       //TODO: VPUNPCKHBW (BX), X9, X2         // c4e1316813 or c5b16813
+       //TODO: VPUNPCKHBW (R11), X9, X2        // c4c1316813
+       //TODO: VPUNPCKHBW X2, X9, X2           // c4e13168d2 or c5b168d2
+       //TODO: VPUNPCKHBW X11, X9, X2          // c4c13168d3
+       //TODO: VPUNPCKHBW (BX), X9, X11        // c46131681b or c531681b
+       //TODO: VPUNPCKHBW (R11), X9, X11       // c44131681b
+       //TODO: VPUNPCKHBW X2, X9, X11          // c4613168da or c53168da
+       //TODO: VPUNPCKHBW X11, X9, X11         // c4413168db
+       //TODO: VPUNPCKHBW (BX), Y15, Y2        // c4e1056813 or c5856813
+       //TODO: VPUNPCKHBW (R11), Y15, Y2       // c4c1056813
+       //TODO: VPUNPCKHBW Y2, Y15, Y2          // c4e10568d2 or c58568d2
+       //TODO: VPUNPCKHBW Y11, Y15, Y2         // c4c10568d3
+       //TODO: VPUNPCKHBW (BX), Y15, Y11       // c46105681b or c505681b
+       //TODO: VPUNPCKHBW (R11), Y15, Y11      // c44105681b
+       //TODO: VPUNPCKHBW Y2, Y15, Y11         // c4610568da or c50568da
+       //TODO: VPUNPCKHBW Y11, Y15, Y11        // c4410568db
+       //TODO: VPUNPCKHDQ (BX), X9, X2         // c4e1316a13 or c5b16a13
+       //TODO: VPUNPCKHDQ (R11), X9, X2        // c4c1316a13
+       //TODO: VPUNPCKHDQ X2, X9, X2           // c4e1316ad2 or c5b16ad2
+       //TODO: VPUNPCKHDQ X11, X9, X2          // c4c1316ad3
+       //TODO: VPUNPCKHDQ (BX), X9, X11        // c461316a1b or c5316a1b
+       //TODO: VPUNPCKHDQ (R11), X9, X11       // c441316a1b
+       //TODO: VPUNPCKHDQ X2, X9, X11          // c461316ada or c5316ada
+       //TODO: VPUNPCKHDQ X11, X9, X11         // c441316adb
+       //TODO: VPUNPCKHDQ (BX), Y15, Y2        // c4e1056a13 or c5856a13
+       //TODO: VPUNPCKHDQ (R11), Y15, Y2       // c4c1056a13
+       //TODO: VPUNPCKHDQ Y2, Y15, Y2          // c4e1056ad2 or c5856ad2
+       //TODO: VPUNPCKHDQ Y11, Y15, Y2         // c4c1056ad3
+       //TODO: VPUNPCKHDQ (BX), Y15, Y11       // c461056a1b or c5056a1b
+       //TODO: VPUNPCKHDQ (R11), Y15, Y11      // c441056a1b
+       //TODO: VPUNPCKHDQ Y2, Y15, Y11         // c461056ada or c5056ada
+       //TODO: VPUNPCKHDQ Y11, Y15, Y11        // c441056adb
+       //TODO: VPUNPCKHQDQ (BX), X9, X2        // c4e1316d13 or c5b16d13
+       //TODO: VPUNPCKHQDQ (R11), X9, X2       // c4c1316d13
+       //TODO: VPUNPCKHQDQ X2, X9, X2          // c4e1316dd2 or c5b16dd2
+       //TODO: VPUNPCKHQDQ X11, X9, X2         // c4c1316dd3
+       //TODO: VPUNPCKHQDQ (BX), X9, X11       // c461316d1b or c5316d1b
+       //TODO: VPUNPCKHQDQ (R11), X9, X11      // c441316d1b
+       //TODO: VPUNPCKHQDQ X2, X9, X11         // c461316dda or c5316dda
+       //TODO: VPUNPCKHQDQ X11, X9, X11        // c441316ddb
+       //TODO: VPUNPCKHQDQ (BX), Y15, Y2       // c4e1056d13 or c5856d13
+       //TODO: VPUNPCKHQDQ (R11), Y15, Y2      // c4c1056d13
+       //TODO: VPUNPCKHQDQ Y2, Y15, Y2         // c4e1056dd2 or c5856dd2
+       //TODO: VPUNPCKHQDQ Y11, Y15, Y2        // c4c1056dd3
+       //TODO: VPUNPCKHQDQ (BX), Y15, Y11      // c461056d1b or c5056d1b
+       //TODO: VPUNPCKHQDQ (R11), Y15, Y11     // c441056d1b
+       //TODO: VPUNPCKHQDQ Y2, Y15, Y11        // c461056dda or c5056dda
+       //TODO: VPUNPCKHQDQ Y11, Y15, Y11       // c441056ddb
+       //TODO: VPUNPCKHWD (BX), X9, X2         // c4e1316913 or c5b16913
+       //TODO: VPUNPCKHWD (R11), X9, X2        // c4c1316913
+       //TODO: VPUNPCKHWD X2, X9, X2           // c4e13169d2 or c5b169d2
+       //TODO: VPUNPCKHWD X11, X9, X2          // c4c13169d3
+       //TODO: VPUNPCKHWD (BX), X9, X11        // c46131691b or c531691b
+       //TODO: VPUNPCKHWD (R11), X9, X11       // c44131691b
+       //TODO: VPUNPCKHWD X2, X9, X11          // c4613169da or c53169da
+       //TODO: VPUNPCKHWD X11, X9, X11         // c4413169db
+       //TODO: VPUNPCKHWD (BX), Y15, Y2        // c4e1056913 or c5856913
+       //TODO: VPUNPCKHWD (R11), Y15, Y2       // c4c1056913
+       //TODO: VPUNPCKHWD Y2, Y15, Y2          // c4e10569d2 or c58569d2
+       //TODO: VPUNPCKHWD Y11, Y15, Y2         // c4c10569d3
+       //TODO: VPUNPCKHWD (BX), Y15, Y11       // c46105691b or c505691b
+       //TODO: VPUNPCKHWD (R11), Y15, Y11      // c44105691b
+       //TODO: VPUNPCKHWD Y2, Y15, Y11         // c4610569da or c50569da
+       //TODO: VPUNPCKHWD Y11, Y15, Y11        // c4410569db
+       //TODO: VPUNPCKLBW (BX), X9, X2         // c4e1316013 or c5b16013
+       //TODO: VPUNPCKLBW (R11), X9, X2        // c4c1316013
+       //TODO: VPUNPCKLBW X2, X9, X2           // c4e13160d2 or c5b160d2
+       //TODO: VPUNPCKLBW X11, X9, X2          // c4c13160d3
+       //TODO: VPUNPCKLBW (BX), X9, X11        // c46131601b or c531601b
+       //TODO: VPUNPCKLBW (R11), X9, X11       // c44131601b
+       //TODO: VPUNPCKLBW X2, X9, X11          // c4613160da or c53160da
+       //TODO: VPUNPCKLBW X11, X9, X11         // c4413160db
+       //TODO: VPUNPCKLBW (BX), Y15, Y2        // c4e1056013 or c5856013
+       //TODO: VPUNPCKLBW (R11), Y15, Y2       // c4c1056013
+       //TODO: VPUNPCKLBW Y2, Y15, Y2          // c4e10560d2 or c58560d2
+       //TODO: VPUNPCKLBW Y11, Y15, Y2         // c4c10560d3
+       //TODO: VPUNPCKLBW (BX), Y15, Y11       // c46105601b or c505601b
+       //TODO: VPUNPCKLBW (R11), Y15, Y11      // c44105601b
+       //TODO: VPUNPCKLBW Y2, Y15, Y11         // c4610560da or c50560da
+       //TODO: VPUNPCKLBW Y11, Y15, Y11        // c4410560db
+       //TODO: VPUNPCKLDQ (BX), X9, X2         // c4e1316213 or c5b16213
+       //TODO: VPUNPCKLDQ (R11), X9, X2        // c4c1316213
+       //TODO: VPUNPCKLDQ X2, X9, X2           // c4e13162d2 or c5b162d2
+       //TODO: VPUNPCKLDQ X11, X9, X2          // c4c13162d3
+       //TODO: VPUNPCKLDQ (BX), X9, X11        // c46131621b or c531621b
+       //TODO: VPUNPCKLDQ (R11), X9, X11       // c44131621b
+       //TODO: VPUNPCKLDQ X2, X9, X11          // c4613162da or c53162da
+       //TODO: VPUNPCKLDQ X11, X9, X11         // c4413162db
+       //TODO: VPUNPCKLDQ (BX), Y15, Y2        // c4e1056213 or c5856213
+       //TODO: VPUNPCKLDQ (R11), Y15, Y2       // c4c1056213
+       //TODO: VPUNPCKLDQ Y2, Y15, Y2          // c4e10562d2 or c58562d2
+       //TODO: VPUNPCKLDQ Y11, Y15, Y2         // c4c10562d3
+       //TODO: VPUNPCKLDQ (BX), Y15, Y11       // c46105621b or c505621b
+       //TODO: VPUNPCKLDQ (R11), Y15, Y11      // c44105621b
+       //TODO: VPUNPCKLDQ Y2, Y15, Y11         // c4610562da or c50562da
+       //TODO: VPUNPCKLDQ Y11, Y15, Y11        // c4410562db
+       //TODO: VPUNPCKLQDQ (BX), X9, X2        // c4e1316c13 or c5b16c13
+       //TODO: VPUNPCKLQDQ (R11), X9, X2       // c4c1316c13
+       //TODO: VPUNPCKLQDQ X2, X9, X2          // c4e1316cd2 or c5b16cd2
+       //TODO: VPUNPCKLQDQ X11, X9, X2         // c4c1316cd3
+       //TODO: VPUNPCKLQDQ (BX), X9, X11       // c461316c1b or c5316c1b
+       //TODO: VPUNPCKLQDQ (R11), X9, X11      // c441316c1b
+       //TODO: VPUNPCKLQDQ X2, X9, X11         // c461316cda or c5316cda
+       //TODO: VPUNPCKLQDQ X11, X9, X11        // c441316cdb
+       //TODO: VPUNPCKLQDQ (BX), Y15, Y2       // c4e1056c13 or c5856c13
+       //TODO: VPUNPCKLQDQ (R11), Y15, Y2      // c4c1056c13
+       //TODO: VPUNPCKLQDQ Y2, Y15, Y2         // c4e1056cd2 or c5856cd2
+       //TODO: VPUNPCKLQDQ Y11, Y15, Y2        // c4c1056cd3
+       //TODO: VPUNPCKLQDQ (BX), Y15, Y11      // c461056c1b or c5056c1b
+       //TODO: VPUNPCKLQDQ (R11), Y15, Y11     // c441056c1b
+       //TODO: VPUNPCKLQDQ Y2, Y15, Y11        // c461056cda or c5056cda
+       //TODO: VPUNPCKLQDQ Y11, Y15, Y11       // c441056cdb
+       //TODO: VPUNPCKLWD (BX), X9, X2         // c4e1316113 or c5b16113
+       //TODO: VPUNPCKLWD (R11), X9, X2        // c4c1316113
+       //TODO: VPUNPCKLWD X2, X9, X2           // c4e13161d2 or c5b161d2
+       //TODO: VPUNPCKLWD X11, X9, X2          // c4c13161d3
+       //TODO: VPUNPCKLWD (BX), X9, X11        // c46131611b or c531611b
+       //TODO: VPUNPCKLWD (R11), X9, X11       // c44131611b
+       //TODO: VPUNPCKLWD X2, X9, X11          // c4613161da or c53161da
+       //TODO: VPUNPCKLWD X11, X9, X11         // c4413161db
+       //TODO: VPUNPCKLWD (BX), Y15, Y2        // c4e1056113 or c5856113
+       //TODO: VPUNPCKLWD (R11), Y15, Y2       // c4c1056113
+       //TODO: VPUNPCKLWD Y2, Y15, Y2          // c4e10561d2 or c58561d2
+       //TODO: VPUNPCKLWD Y11, Y15, Y2         // c4c10561d3
+       //TODO: VPUNPCKLWD (BX), Y15, Y11       // c46105611b or c505611b
+       //TODO: VPUNPCKLWD (R11), Y15, Y11      // c44105611b
+       //TODO: VPUNPCKLWD Y2, Y15, Y11         // c4610561da or c50561da
+       //TODO: VPUNPCKLWD Y11, Y15, Y11        // c4410561db
+       VPXOR (BX), X9, X2                      // c4e131ef13 or c5b1ef13
+       VPXOR (R11), X9, X2                     // c4c131ef13
+       VPXOR X2, X9, X2                        // c4e131efd2 or c5b1efd2
+       VPXOR X11, X9, X2                       // c4c131efd3
+       VPXOR (BX), X9, X11                     // c46131ef1b or c531ef1b
+       VPXOR (R11), X9, X11                    // c44131ef1b
+       VPXOR X2, X9, X11                       // c46131efda or c531efda
+       VPXOR X11, X9, X11                      // c44131efdb
+       VPXOR (BX), Y15, Y2                     // c4e105ef13 or c585ef13
+       VPXOR (R11), Y15, Y2                    // c4c105ef13
+       VPXOR Y2, Y15, Y2                       // c4e105efd2 or c585efd2
+       VPXOR Y11, Y15, Y2                      // c4c105efd3
+       VPXOR (BX), Y15, Y11                    // c46105ef1b or c505ef1b
+       VPXOR (R11), Y15, Y11                   // c44105ef1b
+       VPXOR Y2, Y15, Y11                      // c46105efda or c505efda
+       VPXOR Y11, Y15, Y11                     // c44105efdb
+       //TODO: VRCPPS (BX), X2                 // c4e1785313 or c5f85313
+       //TODO: VRCPPS (R11), X2                // c4c1785313
+       //TODO: VRCPPS X2, X2                   // c4e17853d2 or c5f853d2
+       //TODO: VRCPPS X11, X2                  // c4c17853d3
+       //TODO: VRCPPS (BX), X11                // c46178531b or c578531b
+       //TODO: VRCPPS (R11), X11               // c44178531b
+       //TODO: VRCPPS X2, X11                  // c4617853da or c57853da
+       //TODO: VRCPPS X11, X11                 // c4417853db
+       //TODO: VRCPPS (BX), Y2                 // c4e17c5313 or c5fc5313
+       //TODO: VRCPPS (R11), Y2                // c4c17c5313
+       //TODO: VRCPPS Y2, Y2                   // c4e17c53d2 or c5fc53d2
+       //TODO: VRCPPS Y11, Y2                  // c4c17c53d3
+       //TODO: VRCPPS (BX), Y11                // c4617c531b or c57c531b
+       //TODO: VRCPPS (R11), Y11               // c4417c531b
+       //TODO: VRCPPS Y2, Y11                  // c4617c53da or c57c53da
+       //TODO: VRCPPS Y11, Y11                 // c4417c53db
+       //TODO: VRCPSS (BX), X9, X2             // c4e1325313 or c5b25313
+       //TODO: VRCPSS (R11), X9, X2            // c4c1325313
+       //TODO: VRCPSS X2, X9, X2               // c4e13253d2 or c5b253d2
+       //TODO: VRCPSS X11, X9, X2              // c4c13253d3
+       //TODO: VRCPSS (BX), X9, X11            // c46132531b or c532531b
+       //TODO: VRCPSS (R11), X9, X11           // c44132531b
+       //TODO: VRCPSS X2, X9, X11              // c4613253da or c53253da
+       //TODO: VRCPSS X11, X9, X11             // c4413253db
+       //TODO: VROUNDPD $7, (BX), X2           // c4e379091307
+       //TODO: VROUNDPD $7, (R11), X2          // c4c379091307
+       //TODO: VROUNDPD $7, X2, X2             // c4e37909d207
+       //TODO: VROUNDPD $7, X11, X2            // c4c37909d307
+       //TODO: VROUNDPD $7, (BX), X11          // c46379091b07
+       //TODO: VROUNDPD $7, (R11), X11         // c44379091b07
+       //TODO: VROUNDPD $7, X2, X11            // c4637909da07
+       //TODO: VROUNDPD $7, X11, X11           // c4437909db07
+       //TODO: VROUNDPD $7, (BX), Y2           // c4e37d091307
+       //TODO: VROUNDPD $7, (R11), Y2          // c4c37d091307
+       //TODO: VROUNDPD $7, Y2, Y2             // c4e37d09d207
+       //TODO: VROUNDPD $7, Y11, Y2            // c4c37d09d307
+       //TODO: VROUNDPD $7, (BX), Y11          // c4637d091b07
+       //TODO: VROUNDPD $7, (R11), Y11         // c4437d091b07
+       //TODO: VROUNDPD $7, Y2, Y11            // c4637d09da07
+       //TODO: VROUNDPD $7, Y11, Y11           // c4437d09db07
+       //TODO: VROUNDPS $7, (BX), X2           // c4e379081307
+       //TODO: VROUNDPS $7, (R11), X2          // c4c379081307
+       //TODO: VROUNDPS $7, X2, X2             // c4e37908d207
+       //TODO: VROUNDPS $7, X11, X2            // c4c37908d307
+       //TODO: VROUNDPS $7, (BX), X11          // c46379081b07
+       //TODO: VROUNDPS $7, (R11), X11         // c44379081b07
+       //TODO: VROUNDPS $7, X2, X11            // c4637908da07
+       //TODO: VROUNDPS $7, X11, X11           // c4437908db07
+       //TODO: VROUNDPS $7, (BX), Y2           // c4e37d081307
+       //TODO: VROUNDPS $7, (R11), Y2          // c4c37d081307
+       //TODO: VROUNDPS $7, Y2, Y2             // c4e37d08d207
+       //TODO: VROUNDPS $7, Y11, Y2            // c4c37d08d307
+       //TODO: VROUNDPS $7, (BX), Y11          // c4637d081b07
+       //TODO: VROUNDPS $7, (R11), Y11         // c4437d081b07
+       //TODO: VROUNDPS $7, Y2, Y11            // c4637d08da07
+       //TODO: VROUNDPS $7, Y11, Y11           // c4437d08db07
+       //TODO: VROUNDSD $7, (BX), X9, X2       // c4e3310b1307
+       //TODO: VROUNDSD $7, (R11), X9, X2      // c4c3310b1307
+       //TODO: VROUNDSD $7, X2, X9, X2         // c4e3310bd207
+       //TODO: VROUNDSD $7, X11, X9, X2        // c4c3310bd307
+       //TODO: VROUNDSD $7, (BX), X9, X11      // c463310b1b07
+       //TODO: VROUNDSD $7, (R11), X9, X11     // c443310b1b07
+       //TODO: VROUNDSD $7, X2, X9, X11        // c463310bda07
+       //TODO: VROUNDSD $7, X11, X9, X11       // c443310bdb07
+       //TODO: VROUNDSS $7, (BX), X9, X2       // c4e3310a1307
+       //TODO: VROUNDSS $7, (R11), X9, X2      // c4c3310a1307
+       //TODO: VROUNDSS $7, X2, X9, X2         // c4e3310ad207
+       //TODO: VROUNDSS $7, X11, X9, X2        // c4c3310ad307
+       //TODO: VROUNDSS $7, (BX), X9, X11      // c463310a1b07
+       //TODO: VROUNDSS $7, (R11), X9, X11     // c443310a1b07
+       //TODO: VROUNDSS $7, X2, X9, X11        // c463310ada07
+       //TODO: VROUNDSS $7, X11, X9, X11       // c443310adb07
+       //TODO: VRSQRTPS (BX), X2               // c4e1785213 or c5f85213
+       //TODO: VRSQRTPS (R11), X2              // c4c1785213
+       //TODO: VRSQRTPS X2, X2                 // c4e17852d2 or c5f852d2
+       //TODO: VRSQRTPS X11, X2                // c4c17852d3
+       //TODO: VRSQRTPS (BX), X11              // c46178521b or c578521b
+       //TODO: VRSQRTPS (R11), X11             // c44178521b
+       //TODO: VRSQRTPS X2, X11                // c4617852da or c57852da
+       //TODO: VRSQRTPS X11, X11               // c4417852db
+       //TODO: VRSQRTPS (BX), Y2               // c4e17c5213 or c5fc5213
+       //TODO: VRSQRTPS (R11), Y2              // c4c17c5213
+       //TODO: VRSQRTPS Y2, Y2                 // c4e17c52d2 or c5fc52d2
+       //TODO: VRSQRTPS Y11, Y2                // c4c17c52d3
+       //TODO: VRSQRTPS (BX), Y11              // c4617c521b or c57c521b
+       //TODO: VRSQRTPS (R11), Y11             // c4417c521b
+       //TODO: VRSQRTPS Y2, Y11                // c4617c52da or c57c52da
+       //TODO: VRSQRTPS Y11, Y11               // c4417c52db
+       //TODO: VRSQRTSS (BX), X9, X2           // c4e1325213 or c5b25213
+       //TODO: VRSQRTSS (R11), X9, X2          // c4c1325213
+       //TODO: VRSQRTSS X2, X9, X2             // c4e13252d2 or c5b252d2
+       //TODO: VRSQRTSS X11, X9, X2            // c4c13252d3
+       //TODO: VRSQRTSS (BX), X9, X11          // c46132521b or c532521b
+       //TODO: VRSQRTSS (R11), X9, X11         // c44132521b
+       //TODO: VRSQRTSS X2, X9, X11            // c4613252da or c53252da
+       //TODO: VRSQRTSS X11, X9, X11           // c4413252db
+       //TODO: VSHUFPD $7, (BX), X9, X2        // c4e131c61307 or c5b1c61307
+       //TODO: VSHUFPD $7, (R11), X9, X2       // c4c131c61307
+       //TODO: VSHUFPD $7, X2, X9, X2          // c4e131c6d207 or c5b1c6d207
+       //TODO: VSHUFPD $7, X11, X9, X2         // c4c131c6d307
+       //TODO: VSHUFPD $7, (BX), X9, X11       // c46131c61b07 or c531c61b07
+       //TODO: VSHUFPD $7, (R11), X9, X11      // c44131c61b07
+       //TODO: VSHUFPD $7, X2, X9, X11         // c46131c6da07 or c531c6da07
+       //TODO: VSHUFPD $7, X11, X9, X11        // c44131c6db07
+       //TODO: VSHUFPD $7, (BX), Y15, Y2       // c4e105c61307 or c585c61307
+       //TODO: VSHUFPD $7, (R11), Y15, Y2      // c4c105c61307
+       //TODO: VSHUFPD $7, Y2, Y15, Y2         // c4e105c6d207 or c585c6d207
+       //TODO: VSHUFPD $7, Y11, Y15, Y2        // c4c105c6d307
+       //TODO: VSHUFPD $7, (BX), Y15, Y11      // c46105c61b07 or c505c61b07
+       //TODO: VSHUFPD $7, (R11), Y15, Y11     // c44105c61b07
+       //TODO: VSHUFPD $7, Y2, Y15, Y11        // c46105c6da07 or c505c6da07
+       //TODO: VSHUFPD $7, Y11, Y15, Y11       // c44105c6db07
+       //TODO: VSHUFPS $7, (BX), X9, X2        // c4e130c61307 or c5b0c61307
+       //TODO: VSHUFPS $7, (R11), X9, X2       // c4c130c61307
+       //TODO: VSHUFPS $7, X2, X9, X2          // c4e130c6d207 or c5b0c6d207
+       //TODO: VSHUFPS $7, X11, X9, X2         // c4c130c6d307
+       //TODO: VSHUFPS $7, (BX), X9, X11       // c46130c61b07 or c530c61b07
+       //TODO: VSHUFPS $7, (R11), X9, X11      // c44130c61b07
+       //TODO: VSHUFPS $7, X2, X9, X11         // c46130c6da07 or c530c6da07
+       //TODO: VSHUFPS $7, X11, X9, X11        // c44130c6db07
+       //TODO: VSHUFPS $7, (BX), Y15, Y2       // c4e104c61307 or c584c61307
+       //TODO: VSHUFPS $7, (R11), Y15, Y2      // c4c104c61307
+       //TODO: VSHUFPS $7, Y2, Y15, Y2         // c4e104c6d207 or c584c6d207
+       //TODO: VSHUFPS $7, Y11, Y15, Y2        // c4c104c6d307
+       //TODO: VSHUFPS $7, (BX), Y15, Y11      // c46104c61b07 or c504c61b07
+       //TODO: VSHUFPS $7, (R11), Y15, Y11     // c44104c61b07
+       //TODO: VSHUFPS $7, Y2, Y15, Y11        // c46104c6da07 or c504c6da07
+       //TODO: VSHUFPS $7, Y11, Y15, Y11       // c44104c6db07
+       //TODO: VSQRTPD (BX), X2                // c4e1795113 or c5f95113
+       //TODO: VSQRTPD (R11), X2               // c4c1795113
+       //TODO: VSQRTPD X2, X2                  // c4e17951d2 or c5f951d2
+       //TODO: VSQRTPD X11, X2                 // c4c17951d3
+       //TODO: VSQRTPD (BX), X11               // c46179511b or c579511b
+       //TODO: VSQRTPD (R11), X11              // c44179511b
+       //TODO: VSQRTPD X2, X11                 // c4617951da or c57951da
+       //TODO: VSQRTPD X11, X11                // c4417951db
+       //TODO: VSQRTPD (BX), Y2                // c4e17d5113 or c5fd5113
+       //TODO: VSQRTPD (R11), Y2               // c4c17d5113
+       //TODO: VSQRTPD Y2, Y2                  // c4e17d51d2 or c5fd51d2
+       //TODO: VSQRTPD Y11, Y2                 // c4c17d51d3
+       //TODO: VSQRTPD (BX), Y11               // c4617d511b or c57d511b
+       //TODO: VSQRTPD (R11), Y11              // c4417d511b
+       //TODO: VSQRTPD Y2, Y11                 // c4617d51da or c57d51da
+       //TODO: VSQRTPD Y11, Y11                // c4417d51db
+       //TODO: VSQRTPS (BX), X2                // c4e1785113 or c5f85113
+       //TODO: VSQRTPS (R11), X2               // c4c1785113
+       //TODO: VSQRTPS X2, X2                  // c4e17851d2 or c5f851d2
+       //TODO: VSQRTPS X11, X2                 // c4c17851d3
+       //TODO: VSQRTPS (BX), X11               // c46178511b or c578511b
+       //TODO: VSQRTPS (R11), X11              // c44178511b
+       //TODO: VSQRTPS X2, X11                 // c4617851da or c57851da
+       //TODO: VSQRTPS X11, X11                // c4417851db
+       //TODO: VSQRTPS (BX), Y2                // c4e17c5113 or c5fc5113
+       //TODO: VSQRTPS (R11), Y2               // c4c17c5113
+       //TODO: VSQRTPS Y2, Y2                  // c4e17c51d2 or c5fc51d2
+       //TODO: VSQRTPS Y11, Y2                 // c4c17c51d3
+       //TODO: VSQRTPS (BX), Y11               // c4617c511b or c57c511b
+       //TODO: VSQRTPS (R11), Y11              // c4417c511b
+       //TODO: VSQRTPS Y2, Y11                 // c4617c51da or c57c51da
+       //TODO: VSQRTPS Y11, Y11                // c4417c51db
+       //TODO: VSQRTSD (BX), X9, X2            // c4e1335113 or c5b35113
+       //TODO: VSQRTSD (R11), X9, X2           // c4c1335113
+       //TODO: VSQRTSD X2, X9, X2              // c4e13351d2 or c5b351d2
+       //TODO: VSQRTSD X11, X9, X2             // c4c13351d3
+       //TODO: VSQRTSD (BX), X9, X11           // c46133511b or c533511b
+       //TODO: VSQRTSD (R11), X9, X11          // c44133511b
+       //TODO: VSQRTSD X2, X9, X11             // c4613351da or c53351da
+       //TODO: VSQRTSD X11, X9, X11            // c4413351db
+       //TODO: VSQRTSS (BX), X9, X2            // c4e1325113 or c5b25113
+       //TODO: VSQRTSS (R11), X9, X2           // c4c1325113
+       //TODO: VSQRTSS X2, X9, X2              // c4e13251d2 or c5b251d2
+       //TODO: VSQRTSS X11, X9, X2             // c4c13251d3
+       //TODO: VSQRTSS (BX), X9, X11           // c46132511b or c532511b
+       //TODO: VSQRTSS (R11), X9, X11          // c44132511b
+       //TODO: VSQRTSS X2, X9, X11             // c4613251da or c53251da
+       //TODO: VSQRTSS X11, X9, X11            // c4413251db
+       //TODO: VSTMXCSR (BX)                   // c4e178ae1b or c5f8ae1b
+       //TODO: VSTMXCSR (R11)                  // c4c178ae1b
+       //TODO: VSUBPD (BX), X9, X2             // c4e1315c13 or c5b15c13
+       //TODO: VSUBPD (R11), X9, X2            // c4c1315c13
+       //TODO: VSUBPD X2, X9, X2               // c4e1315cd2 or c5b15cd2
+       //TODO: VSUBPD X11, X9, X2              // c4c1315cd3
+       //TODO: VSUBPD (BX), X9, X11            // c461315c1b or c5315c1b
+       //TODO: VSUBPD (R11), X9, X11           // c441315c1b
+       //TODO: VSUBPD X2, X9, X11              // c461315cda or c5315cda
+       //TODO: VSUBPD X11, X9, X11             // c441315cdb
+       //TODO: VSUBPD (BX), Y15, Y2            // c4e1055c13 or c5855c13
+       //TODO: VSUBPD (R11), Y15, Y2           // c4c1055c13
+       //TODO: VSUBPD Y2, Y15, Y2              // c4e1055cd2 or c5855cd2
+       //TODO: VSUBPD Y11, Y15, Y2             // c4c1055cd3
+       //TODO: VSUBPD (BX), Y15, Y11           // c461055c1b or c5055c1b
+       //TODO: VSUBPD (R11), Y15, Y11          // c441055c1b
+       //TODO: VSUBPD Y2, Y15, Y11             // c461055cda or c5055cda
+       //TODO: VSUBPD Y11, Y15, Y11            // c441055cdb
+       //TODO: VSUBPS (BX), X9, X2             // c4e1305c13 or c5b05c13
+       //TODO: VSUBPS (R11), X9, X2            // c4c1305c13
+       //TODO: VSUBPS X2, X9, X2               // c4e1305cd2 or c5b05cd2
+       //TODO: VSUBPS X11, X9, X2              // c4c1305cd3
+       //TODO: VSUBPS (BX), X9, X11            // c461305c1b or c5305c1b
+       //TODO: VSUBPS (R11), X9, X11           // c441305c1b
+       //TODO: VSUBPS X2, X9, X11              // c461305cda or c5305cda
+       //TODO: VSUBPS X11, X9, X11             // c441305cdb
+       //TODO: VSUBPS (BX), Y15, Y2            // c4e1045c13 or c5845c13
+       //TODO: VSUBPS (R11), Y15, Y2           // c4c1045c13
+       //TODO: VSUBPS Y2, Y15, Y2              // c4e1045cd2 or c5845cd2
+       //TODO: VSUBPS Y11, Y15, Y2             // c4c1045cd3
+       //TODO: VSUBPS (BX), Y15, Y11           // c461045c1b or c5045c1b
+       //TODO: VSUBPS (R11), Y15, Y11          // c441045c1b
+       //TODO: VSUBPS Y2, Y15, Y11             // c461045cda or c5045cda
+       //TODO: VSUBPS Y11, Y15, Y11            // c441045cdb
+       //TODO: VSUBSD (BX), X9, X2             // c4e1335c13 or c5b35c13
+       //TODO: VSUBSD (R11), X9, X2            // c4c1335c13
+       //TODO: VSUBSD X2, X9, X2               // c4e1335cd2 or c5b35cd2
+       //TODO: VSUBSD X11, X9, X2              // c4c1335cd3
+       //TODO: VSUBSD (BX), X9, X11            // c461335c1b or c5335c1b
+       //TODO: VSUBSD (R11), X9, X11           // c441335c1b
+       //TODO: VSUBSD X2, X9, X11              // c461335cda or c5335cda
+       //TODO: VSUBSD X11, X9, X11             // c441335cdb
+       //TODO: VSUBSS (BX), X9, X2             // c4e1325c13 or c5b25c13
+       //TODO: VSUBSS (R11), X9, X2            // c4c1325c13
+       //TODO: VSUBSS X2, X9, X2               // c4e1325cd2 or c5b25cd2
+       //TODO: VSUBSS X11, X9, X2              // c4c1325cd3
+       //TODO: VSUBSS (BX), X9, X11            // c461325c1b or c5325c1b
+       //TODO: VSUBSS (R11), X9, X11           // c441325c1b
+       //TODO: VSUBSS X2, X9, X11              // c461325cda or c5325cda
+       //TODO: VSUBSS X11, X9, X11             // c441325cdb
+       //TODO: VTESTPD (BX), X2                // c4e2790f13
+       //TODO: VTESTPD (R11), X2               // c4c2790f13
+       //TODO: VTESTPD X2, X2                  // c4e2790fd2
+       //TODO: VTESTPD X11, X2                 // c4c2790fd3
+       //TODO: VTESTPD (BX), X11               // c462790f1b
+       //TODO: VTESTPD (R11), X11              // c442790f1b
+       //TODO: VTESTPD X2, X11                 // c462790fda
+       //TODO: VTESTPD X11, X11                // c442790fdb
+       //TODO: VTESTPD (BX), Y2                // c4e27d0f13
+       //TODO: VTESTPD (R11), Y2               // c4c27d0f13
+       //TODO: VTESTPD Y2, Y2                  // c4e27d0fd2
+       //TODO: VTESTPD Y11, Y2                 // c4c27d0fd3
+       //TODO: VTESTPD (BX), Y11               // c4627d0f1b
+       //TODO: VTESTPD (R11), Y11              // c4427d0f1b
+       //TODO: VTESTPD Y2, Y11                 // c4627d0fda
+       //TODO: VTESTPD Y11, Y11                // c4427d0fdb
+       //TODO: VTESTPS (BX), X2                // c4e2790e13
+       //TODO: VTESTPS (R11), X2               // c4c2790e13
+       //TODO: VTESTPS X2, X2                  // c4e2790ed2
+       //TODO: VTESTPS X11, X2                 // c4c2790ed3
+       //TODO: VTESTPS (BX), X11               // c462790e1b
+       //TODO: VTESTPS (R11), X11              // c442790e1b
+       //TODO: VTESTPS X2, X11                 // c462790eda
+       //TODO: VTESTPS X11, X11                // c442790edb
+       //TODO: VTESTPS (BX), Y2                // c4e27d0e13
+       //TODO: VTESTPS (R11), Y2               // c4c27d0e13
+       //TODO: VTESTPS Y2, Y2                  // c4e27d0ed2
+       //TODO: VTESTPS Y11, Y2                 // c4c27d0ed3
+       //TODO: VTESTPS (BX), Y11               // c4627d0e1b
+       //TODO: VTESTPS (R11), Y11              // c4427d0e1b
+       //TODO: VTESTPS Y2, Y11                 // c4627d0eda
+       //TODO: VTESTPS Y11, Y11                // c4427d0edb
+       //TODO: VUCOMISD (BX), X2               // c4e1792e13 or c5f92e13
+       //TODO: VUCOMISD (R11), X2              // c4c1792e13
+       //TODO: VUCOMISD X2, X2                 // c4e1792ed2 or c5f92ed2
+       //TODO: VUCOMISD X11, X2                // c4c1792ed3
+       //TODO: VUCOMISD (BX), X11              // c461792e1b or c5792e1b
+       //TODO: VUCOMISD (R11), X11             // c441792e1b
+       //TODO: VUCOMISD X2, X11                // c461792eda or c5792eda
+       //TODO: VUCOMISD X11, X11               // c441792edb
+       //TODO: VUCOMISS (BX), X2               // c4e1782e13 or c5f82e13
+       //TODO: VUCOMISS (R11), X2              // c4c1782e13
+       //TODO: VUCOMISS X2, X2                 // c4e1782ed2 or c5f82ed2
+       //TODO: VUCOMISS X11, X2                // c4c1782ed3
+       //TODO: VUCOMISS (BX), X11              // c461782e1b or c5782e1b
+       //TODO: VUCOMISS (R11), X11             // c441782e1b
+       //TODO: VUCOMISS X2, X11                // c461782eda or c5782eda
+       //TODO: VUCOMISS X11, X11               // c441782edb
+       //TODO: VUNPCKHPD (BX), X9, X2          // c4e1311513 or c5b11513
+       //TODO: VUNPCKHPD (R11), X9, X2         // c4c1311513
+       //TODO: VUNPCKHPD X2, X9, X2            // c4e13115d2 or c5b115d2
+       //TODO: VUNPCKHPD X11, X9, X2           // c4c13115d3
+       //TODO: VUNPCKHPD (BX), X9, X11         // c46131151b or c531151b
+       //TODO: VUNPCKHPD (R11), X9, X11        // c44131151b
+       //TODO: VUNPCKHPD X2, X9, X11           // c4613115da or c53115da
+       //TODO: VUNPCKHPD X11, X9, X11          // c4413115db
+       //TODO: VUNPCKHPD (BX), Y15, Y2         // c4e1051513 or c5851513
+       //TODO: VUNPCKHPD (R11), Y15, Y2        // c4c1051513
+       //TODO: VUNPCKHPD Y2, Y15, Y2           // c4e10515d2 or c58515d2
+       //TODO: VUNPCKHPD Y11, Y15, Y2          // c4c10515d3
+       //TODO: VUNPCKHPD (BX), Y15, Y11        // c46105151b or c505151b
+       //TODO: VUNPCKHPD (R11), Y15, Y11       // c44105151b
+       //TODO: VUNPCKHPD Y2, Y15, Y11          // c4610515da or c50515da
+       //TODO: VUNPCKHPD Y11, Y15, Y11         // c4410515db
+       //TODO: VUNPCKHPS (BX), X9, X2          // c4e1301513 or c5b01513
+       //TODO: VUNPCKHPS (R11), X9, X2         // c4c1301513
+       //TODO: VUNPCKHPS X2, X9, X2            // c4e13015d2 or c5b015d2
+       //TODO: VUNPCKHPS X11, X9, X2           // c4c13015d3
+       //TODO: VUNPCKHPS (BX), X9, X11         // c46130151b or c530151b
+       //TODO: VUNPCKHPS (R11), X9, X11        // c44130151b
+       //TODO: VUNPCKHPS X2, X9, X11           // c4613015da or c53015da
+       //TODO: VUNPCKHPS X11, X9, X11          // c4413015db
+       //TODO: VUNPCKHPS (BX), Y15, Y2         // c4e1041513 or c5841513
+       //TODO: VUNPCKHPS (R11), Y15, Y2        // c4c1041513
+       //TODO: VUNPCKHPS Y2, Y15, Y2           // c4e10415d2 or c58415d2
+       //TODO: VUNPCKHPS Y11, Y15, Y2          // c4c10415d3
+       //TODO: VUNPCKHPS (BX), Y15, Y11        // c46104151b or c504151b
+       //TODO: VUNPCKHPS (R11), Y15, Y11       // c44104151b
+       //TODO: VUNPCKHPS Y2, Y15, Y11          // c4610415da or c50415da
+       //TODO: VUNPCKHPS Y11, Y15, Y11         // c4410415db
+       //TODO: VUNPCKLPD (BX), X9, X2          // c4e1311413 or c5b11413
+       //TODO: VUNPCKLPD (R11), X9, X2         // c4c1311413
+       //TODO: VUNPCKLPD X2, X9, X2            // c4e13114d2 or c5b114d2
+       //TODO: VUNPCKLPD X11, X9, X2           // c4c13114d3
+       //TODO: VUNPCKLPD (BX), X9, X11         // c46131141b or c531141b
+       //TODO: VUNPCKLPD (R11), X9, X11        // c44131141b
+       //TODO: VUNPCKLPD X2, X9, X11           // c4613114da or c53114da
+       //TODO: VUNPCKLPD X11, X9, X11          // c4413114db
+       //TODO: VUNPCKLPD (BX), Y15, Y2         // c4e1051413 or c5851413
+       //TODO: VUNPCKLPD (R11), Y15, Y2        // c4c1051413
+       //TODO: VUNPCKLPD Y2, Y15, Y2           // c4e10514d2 or c58514d2
+       //TODO: VUNPCKLPD Y11, Y15, Y2          // c4c10514d3
+       //TODO: VUNPCKLPD (BX), Y15, Y11        // c46105141b or c505141b
+       //TODO: VUNPCKLPD (R11), Y15, Y11       // c44105141b
+       //TODO: VUNPCKLPD Y2, Y15, Y11          // c4610514da or c50514da
+       //TODO: VUNPCKLPD Y11, Y15, Y11         // c4410514db
+       //TODO: VUNPCKLPS (BX), X9, X2          // c4e1301413 or c5b01413
+       //TODO: VUNPCKLPS (R11), X9, X2         // c4c1301413
+       //TODO: VUNPCKLPS X2, X9, X2            // c4e13014d2 or c5b014d2
+       //TODO: VUNPCKLPS X11, X9, X2           // c4c13014d3
+       //TODO: VUNPCKLPS (BX), X9, X11         // c46130141b or c530141b
+       //TODO: VUNPCKLPS (R11), X9, X11        // c44130141b
+       //TODO: VUNPCKLPS X2, X9, X11           // c4613014da or c53014da
+       //TODO: VUNPCKLPS X11, X9, X11          // c4413014db
+       //TODO: VUNPCKLPS (BX), Y15, Y2         // c4e1041413 or c5841413
+       //TODO: VUNPCKLPS (R11), Y15, Y2        // c4c1041413
+       //TODO: VUNPCKLPS Y2, Y15, Y2           // c4e10414d2 or c58414d2
+       //TODO: VUNPCKLPS Y11, Y15, Y2          // c4c10414d3
+       //TODO: VUNPCKLPS (BX), Y15, Y11        // c46104141b or c504141b
+       //TODO: VUNPCKLPS (R11), Y15, Y11       // c44104141b
+       //TODO: VUNPCKLPS Y2, Y15, Y11          // c4610414da or c50414da
+       //TODO: VUNPCKLPS Y11, Y15, Y11         // c4410414db
+       //TODO: VXORPD (BX), X9, X2             // c4e1315713 or c5b15713
+       //TODO: VXORPD (R11), X9, X2            // c4c1315713
+       //TODO: VXORPD X2, X9, X2               // c4e13157d2 or c5b157d2
+       //TODO: VXORPD X11, X9, X2              // c4c13157d3
+       //TODO: VXORPD (BX), X9, X11            // c46131571b or c531571b
+       //TODO: VXORPD (R11), X9, X11           // c44131571b
+       //TODO: VXORPD X2, X9, X11              // c4613157da or c53157da
+       //TODO: VXORPD X11, X9, X11             // c4413157db
+       //TODO: VXORPD (BX), Y15, Y2            // c4e1055713 or c5855713
+       //TODO: VXORPD (R11), Y15, Y2           // c4c1055713
+       //TODO: VXORPD Y2, Y15, Y2              // c4e10557d2 or c58557d2
+       //TODO: VXORPD Y11, Y15, Y2             // c4c10557d3
+       //TODO: VXORPD (BX), Y15, Y11           // c46105571b or c505571b
+       //TODO: VXORPD (R11), Y15, Y11          // c44105571b
+       //TODO: VXORPD Y2, Y15, Y11             // c4610557da or c50557da
+       //TODO: VXORPD Y11, Y15, Y11            // c4410557db
+       //TODO: VXORPS (BX), X9, X2             // c4e1305713 or c5b05713
+       //TODO: VXORPS (R11), X9, X2            // c4c1305713
+       //TODO: VXORPS X2, X9, X2               // c4e13057d2 or c5b057d2
+       //TODO: VXORPS X11, X9, X2              // c4c13057d3
+       //TODO: VXORPS (BX), X9, X11            // c46130571b or c530571b
+       //TODO: VXORPS (R11), X9, X11           // c44130571b
+       //TODO: VXORPS X2, X9, X11              // c4613057da or c53057da
+       //TODO: VXORPS X11, X9, X11             // c4413057db
+       //TODO: VXORPS (BX), Y15, Y2            // c4e1045713 or c5845713
+       //TODO: VXORPS (R11), Y15, Y2           // c4c1045713
+       //TODO: VXORPS Y2, Y15, Y2              // c4e10457d2 or c58457d2
+       //TODO: VXORPS Y11, Y15, Y2             // c4c10457d3
+       //TODO: VXORPS (BX), Y15, Y11           // c46104571b or c504571b
+       //TODO: VXORPS (R11), Y15, Y11          // c44104571b
+       //TODO: VXORPS Y2, Y15, Y11             // c4610457da or c50457da
+       //TODO: VXORPS Y11, Y15, Y11            // c4410457db
+       //TODO: VZEROALL                        // c4e17c77 or c5fc77
+       VZEROUPPER                              // c4e17877 or c5f877
+       WBINVD                                  // 0f09
+       //TODO: WRFSBASE DX                     // f30faed2 or f3480faed2
+       //TODO: WRFSBASE R11                    // f3410faed3 or f3490faed3
+       //TODO: WRGSBASE DX                     // f30faeda or f3480faeda
+       //TODO: WRGSBASE R11                    // f3410faedb or f3490faedb
+       WRMSR                                   // 0f30
+       //TODO: WRPKRU                          // 0f01ef
+       XABORT $7                               // c6f807
+       XADDW DX, (BX)                          // 660fc113
+       XADDW R11, (BX)                         // 66440fc11b
+       XADDW DX, (R11)                         // 66410fc113
+       XADDW R11, (R11)                        // 66450fc11b
+       XADDW DX, DX                            // 660fc1d2
+       XADDW R11, DX                           // 66440fc1da
+       XADDW DX, R11                           // 66410fc1d3
+       XADDW R11, R11                          // 66450fc1db
+       XADDL DX, (BX)                          // 0fc113
+       XADDL R11, (BX)                         // 440fc11b
+       XADDL DX, (R11)                         // 410fc113
+       XADDL R11, (R11)                        // 450fc11b
+       XADDL DX, DX                            // 0fc1d2
+       XADDL R11, DX                           // 440fc1da
+       XADDL DX, R11                           // 410fc1d3
+       XADDL R11, R11                          // 450fc1db
+       XADDQ DX, (BX)                          // 480fc113
+       XADDQ R11, (BX)                         // 4c0fc11b
+       XADDQ DX, (R11)                         // 490fc113
+       XADDQ R11, (R11)                        // 4d0fc11b
+       XADDQ DX, DX                            // 480fc1d2
+       XADDQ R11, DX                           // 4c0fc1da
+       XADDQ DX, R11                           // 490fc1d3
+       XADDQ R11, R11                          // 4d0fc1db
+       XADDB DL, (BX)                          // 0fc013
+       XADDB R11, (BX)                         // 440fc01b
+       XADDB DL, (R11)                         // 410fc013
+       XADDB R11, (R11)                        // 450fc01b
+       XADDB DL, DL                            // 0fc0d2
+       XADDB R11, DL                           // 440fc0da
+       XADDB DL, R11                           // 410fc0d3
+       XADDB R11, R11                          // 450fc0db
+       //TODO: XBEGIN .+$0x1122                // 66c7f82211
+       //TODO: XBEGIN .+$0x11223344            // c7f844332211
+       XCHGW DX, (BX)                          // 668713
+       XCHGW R11, (BX)                         // 6644871b
+       XCHGW DX, (R11)                         // 66418713
+       XCHGW R11, (R11)                        // 6645871b
+       XCHGW DX, DX                            // 6687d2
+       XCHGW R11, DX                           // 664487da
+       XCHGW DX, R11                           // 664187d3
+       XCHGW R11, R11                          // 664587db
+       XCHGL DX, (BX)                          // 8713
+       XCHGL R11, (BX)                         // 44871b
+       XCHGL DX, (R11)                         // 418713
+       XCHGL R11, (R11)                        // 45871b
+       XCHGL DX, DX                            // 87d2
+       XCHGL R11, DX                           // 4487da
+       XCHGL DX, R11                           // 4187d3
+       XCHGL R11, R11                          // 4587db
+       XCHGQ DX, (BX)                          // 488713
+       XCHGQ R11, (BX)                         // 4c871b
+       XCHGQ DX, (R11)                         // 498713
+       XCHGQ R11, (R11)                        // 4d871b
+       XCHGQ DX, DX                            // 4887d2
+       XCHGQ R11, DX                           // 4c87da
+       XCHGQ DX, R11                           // 4987d3
+       XCHGQ R11, R11                          // 4d87db
+       XCHGB DL, (BX)                          // 8613
+       XCHGB R11, (BX)                         // 44861b
+       XCHGB DL, (R11)                         // 418613
+       XCHGB R11, (R11)                        // 45861b
+       XCHGB DL, DL                            // 86d2
+       XCHGB R11, DL                           // 4486da
+       XCHGB DL, R11                           // 4186d3
+       XCHGB R11, R11                          // 4586db
+       XCHGW AX, DX                            // 6692
+       XCHGW AX, R11                           // 664193
+       XCHGL AX, DX                            // 92
+       XCHGL AX, R11                           // 4193
+       XCHGQ AX, DX                            // 4892
+       XCHGQ AX, R11                           // 4993
+       XEND                                    // 0f01d5
+       XGETBV                                  // 0f01d0
+       XLAT                                    // d7
+       XORB $7, AL                             // 3407
+       XORW $61731, AX                         // 663523f1
+       XORL $4045620583, AX                    // 35674523f1
+       XORQ $-249346713, AX                    // 4835674523f1
+       XORW $61731, (BX)                       // 66813323f1
+       XORW $61731, (R11)                      // 6641813323f1
+       XORW $61731, DX                         // 6681f223f1
+       XORW $61731, R11                        // 664181f323f1
+       XORW $7, (BX)                           // 66833307
+       XORW $7, (R11)                          // 6641833307
+       XORW $7, DX                             // 6683f207
+       XORW $7, R11                            // 664183f307
+       XORW DX, (BX)                           // 663113
+       XORW R11, (BX)                          // 6644311b
+       XORW DX, (R11)                          // 66413113
+       XORW R11, (R11)                         // 6645311b
+       XORW DX, DX                             // 6631d2 or 6633d2
+       XORW R11, DX                            // 664431da or 664133d3
+       XORW DX, R11                            // 664131d3 or 664433da
+       XORW R11, R11                           // 664531db or 664533db
+       XORL $4045620583, (BX)                  // 8133674523f1
+       XORL $4045620583, (R11)                 // 418133674523f1
+       XORL $4045620583, DX                    // 81f2674523f1
+       XORL $4045620583, R11                   // 4181f3674523f1
+       XORL $7, (BX)                           // 833307
+       XORL $7, (R11)                          // 41833307
+       XORL $7, DX                             // 83f207
+       XORL $7, R11                            // 4183f307
+       XORL DX, (BX)                           // 3113
+       XORL R11, (BX)                          // 44311b
+       XORL DX, (R11)                          // 413113
+       XORL R11, (R11)                         // 45311b
+       XORL DX, DX                             // 31d2 or 33d2
+       XORL R11, DX                            // 4431da or 4133d3
+       XORL DX, R11                            // 4131d3 or 4433da
+       XORL R11, R11                           // 4531db or 4533db
+       XORQ $-249346713, (BX)                  // 488133674523f1
+       XORQ $-249346713, (R11)                 // 498133674523f1
+       XORQ $-249346713, DX                    // 4881f2674523f1
+       XORQ $-249346713, R11                   // 4981f3674523f1
+       XORQ $7, (BX)                           // 48833307
+       XORQ $7, (R11)                          // 49833307
+       XORQ $7, DX                             // 4883f207
+       XORQ $7, R11                            // 4983f307
+       XORQ DX, (BX)                           // 483113
+       XORQ R11, (BX)                          // 4c311b
+       XORQ DX, (R11)                          // 493113
+       XORQ R11, (R11)                         // 4d311b
+       XORQ DX, DX                             // 4831d2 or 4833d2
+       XORQ R11, DX                            // 4c31da or 4933d3
+       XORQ DX, R11                            // 4931d3 or 4c33da
+       XORQ R11, R11                           // 4d31db or 4d33db
+       XORB $7, (BX)                           // 803307
+       XORB $7, (R11)                          // 41803307
+       XORB $7, DL                             // 80f207
+       XORB $7, R11                            // 4180f307
+       XORB DL, (BX)                           // 3013
+       XORB R11, (BX)                          // 44301b
+       XORB DL, (R11)                          // 413013
+       XORB R11, (R11)                         // 45301b
+       XORB DL, DL                             // 30d2 or 32d2
+       XORB R11, DL                            // 4430da or 4132d3
+       XORB DL, R11                            // 4130d3 or 4432da
+       XORB R11, R11                           // 4530db or 4532db
+       XORW (BX), DX                           // 663313
+       XORW (R11), DX                          // 66413313
+       XORW (BX), R11                          // 6644331b
+       XORW (R11), R11                         // 6645331b
+       XORL (BX), DX                           // 3313
+       XORL (R11), DX                          // 413313
+       XORL (BX), R11                          // 44331b
+       XORL (R11), R11                         // 45331b
+       XORQ (BX), DX                           // 483313
+       XORQ (R11), DX                          // 493313
+       XORQ (BX), R11                          // 4c331b
+       XORQ (R11), R11                         // 4d331b
+       XORB (BX), DL                           // 3213
+       XORB (R11), DL                          // 413213
+       XORB (BX), R11                          // 44321b
+       XORB (R11), R11                         // 45321b
+       XORPD (BX), X2                          // 660f5713
+       XORPD (R11), X2                         // 66410f5713
+       XORPD X2, X2                            // 660f57d2
+       XORPD X11, X2                           // 66410f57d3
+       XORPD (BX), X11                         // 66440f571b
+       XORPD (R11), X11                        // 66450f571b
+       XORPD X2, X11                           // 66440f57da
+       XORPD X11, X11                          // 66450f57db
+       XORPS (BX), X2                          // 0f5713
+       XORPS (R11), X2                         // 410f5713
+       XORPS X2, X2                            // 0f57d2
+       XORPS X11, X2                           // 410f57d3
+       XORPS (BX), X11                         // 440f571b
+       XORPS (R11), X11                        // 450f571b
+       XORPS X2, X11                           // 440f57da
+       XORPS X11, X11                          // 450f57db
+       //TODO: XRSTOR (BX)                     // 0fae2b
+       //TODO: XRSTOR (R11)                    // 410fae2b
+       //TODO: XRSTOR64 (BX)                   // 480fae2b
+       //TODO: XRSTOR64 (R11)                  // 490fae2b
+       //TODO: XRSTORS (BX)                    // 0fc71b
+       //TODO: XRSTORS (R11)                   // 410fc71b
+       //TODO: XRSTORS64 (BX)                  // 480fc71b
+       //TODO: XRSTORS64 (R11)                 // 490fc71b
+       //TODO: XSAVE (BX)                      // 0fae23
+       //TODO: XSAVE (R11)                     // 410fae23
+       //TODO: XSAVE64 (BX)                    // 480fae23
+       //TODO: XSAVE64 (R11)                   // 490fae23
+       //TODO: XSAVEC (BX)                     // 0fc723
+       //TODO: XSAVEC (R11)                    // 410fc723
+       //TODO: XSAVEC64 (BX)                   // 480fc723
+       //TODO: XSAVEC64 (R11)                  // 490fc723
+       //TODO: XSAVEOPT (BX)                   // 0fae33
+       //TODO: XSAVEOPT (R11)                  // 410fae33
+       //TODO: XSAVEOPT64 (BX)                 // 480fae33
+       //TODO: XSAVEOPT64 (R11)                // 490fae33
+       //TODO: XSAVES (BX)                     // 0fc72b
+       //TODO: XSAVES (R11)                    // 410fc72b
+       //TODO: XSAVES64 (BX)                   // 480fc72b
+       //TODO: XSAVES64 (R11)                  // 490fc72b
+       //TODO: XSETBV                          // 0f01d1
+       XTEST                                   // 0f01d6
+       RET

diff --git a/src/cmd/asm/internal/asm/testdata/amd64error.s b/src/cmd/asm/internal/asm/testdata/amd64error.s
new file mode 100644 (file)
index 0000000..81ca11b
--- /dev/null
+++ b/src/cmd/asm/internal/asm/testdata/amd64error.s
@@ -0,0 +1,8 @@
+// Copyright 2016 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+TEXT errors(SB),$0
+       MOVL    foo<>(SB)(AX), AX       // ERROR "invalid instruction"
+       MOVL    (AX)(SP*1), AX          // ERROR "invalid instruction"
+       RET

diff --git a/src/cmd/asm/internal/asm/testdata/arm.out b/src/cmd/asm/internal/asm/testdata/arm.out
deleted file mode 100644 (file)
index 7d79bf3..0000000
--- a/src/cmd/asm/internal/asm/testdata/arm.out
+++ /dev/null
@@ -1,60 +0,0 @@
-9 00001 (testdata/arm.s:9)     TEXT    foo(SB), 0, $0
-18 00002 (testdata/arm.s:18)   ADD     $1, R2, R3
-19 00003 (testdata/arm.s:19)   ADD     R1<<R2, R3, R4
-20 00004 (testdata/arm.s:20)   ADD     R1>>R2, R3, R4
-21 00005 (testdata/arm.s:21)   ADD     R1@>R2, R3, R4
-22 00006 (testdata/arm.s:22)   ADD     R1->R2, R3, R4
-23 00007 (testdata/arm.s:23)   ADD     R1, R2, R3
-24 00008 (testdata/arm.s:24)   ADD     R1<<R2, R3, R4
-34 00009 (testdata/arm.s:34)   ADD     $1, R2
-35 00010 (testdata/arm.s:35)   ADD     R1<<R2, R3
-36 00011 (testdata/arm.s:36)   ADD     R1>>R2, R3
-37 00012 (testdata/arm.s:37)   ADD     R1@>R2, R3
-38 00013 (testdata/arm.s:38)   ADD     R1->R2, R3
-39 00014 (testdata/arm.s:39)   ADD     R1, R2
-48 00015 (testdata/arm.s:48)   CLZ.S   R1, R2
-57 00016 (testdata/arm.s:57)   MOVW.S  R1, R2
-58 00017 (testdata/arm.s:58)   MOVW.S  $1, R2
-59 00018 (testdata/arm.s:59)   MOVW.S  R1<<R2, R3
-68 00019 (testdata/arm.s:68)   JMP.S   20(PC)
-74 00020 (testdata/arm.s:74)   JMP.S   (R2)
-75 00021 (testdata/arm.s:75)   JMP.S   foo(SB)
-76 00022 (testdata/arm.s:76)   JMP.S   bar<>(SB)
-85 00023 (testdata/arm.s:85)   BX      (R2)
-94 00024 (testdata/arm.s:94)   BEQ     25(PC)
-103 00025 (testdata/arm.s:103) SWI.S   R1
-104 00026 (testdata/arm.s:104) SWI.S   (R1)
-105 00027 (testdata/arm.s:105) SWI.S   foo(SB)
-114 00028 (testdata/arm.s:114) CMP.S   $1, R2
-115 00029 (testdata/arm.s:115) CMP.S   R1<<R2, R3
-116 00030 (testdata/arm.s:116) CMP.S   R1, R2
-130 00031 (testdata/arm.s:130) MOVM    (R1), [R2,R5,R8,g]
-131 00032 (testdata/arm.s:131) MOVM    (R1), [R2,R3,R4,R5]
-132 00033 (testdata/arm.s:132) MOVM.S  (R1), [R2]
-143 00034 (testdata/arm.s:143) MOVM    [R2,R5,R8,g], (R1)
-144 00035 (testdata/arm.s:144) MOVM    [R2,R3,R4,R5], (R1)
-145 00036 (testdata/arm.s:145) MOVM.S  [R2], (R1)
-154 00037 (testdata/arm.s:154) STREX.S (R2), R1, R3
-160 00038 (testdata/arm.s:160) STREX.S (R2), R1, R1
-166 00039 (testdata/arm.s:166) STREX.S (R2), R3, R3
-175 00040 (testdata/arm.s:175) WORD    $1234
-184 00041 (testdata/arm.s:184) ABSF.S  F1, F2
-190 00042 (testdata/arm.s:190) ADDD.S  F1, F2
-191 00043 (testdata/arm.s:191) ADDD.S  $(0.5), F2
-197 00044 (testdata/arm.s:197) ADDD.S  F1, F2, F3
-198 00045 (testdata/arm.s:198) ADDD.S  $(0.5), F2, F3
-204 00046 (testdata/arm.s:204) CMPD.S  F1, F2
-228 00047 (testdata/arm.s:228) MRC     $8301712627
-229 00048 (testdata/arm.s:229) MRC     $8300664051
-238 00049 (testdata/arm.s:238) MULL    R1, R2, (R3, R4)
-250 00050 (testdata/arm.s:250) MULAWT  R1, R2, R3, R4
-258 00051 (testdata/arm.s:258) PLD     (R1)
-259 00052 (testdata/arm.s:259) PLD     4(R1)
-268 00053 (testdata/arm.s:268) RET
-272 00054 (testdata/arm.s:272) JMP     foo(SB)
-273 00055 (testdata/arm.s:273) CALL    foo(SB)
-274 00056 (testdata/arm.s:274) JMP     foo(SB)
-275 00057 (testdata/arm.s:275) CALL    foo(SB)
-278 00058 (testdata/arm.s:278) CMPF    F1, F2
-279 00059 (testdata/arm.s:279) CMPD    F1, F2
-288 00060 (testdata/arm.s:288) END

diff --git a/src/cmd/asm/internal/asm/testdata/arm.s b/src/cmd/asm/internal/asm/testdata/arm.s
index f5ba3a85759d7c33be35809a12208b8725115e8f..8062750250386df4cf21388a1e71ec24a5439bb8 100644 (file)
--- a/src/cmd/asm/internal/asm/testdata/arm.s
+++ b/src/cmd/asm/internal/asm/testdata/arm.s
@@ -6,7 +6,7 @@
 // the old assembler's (5a's) grammar and hand-writing complete
 // instructions for each rule, to guarantee we cover the same space.
 
-TEXT   foo(SB), 0, $0
+TEXT   foo(SB), 7, $0
 
 // ADD
 //
@@ -21,7 +21,7 @@ TEXT  foo(SB), 0, $0
        ADD     R1@>R2, R3, R4
        ADD     R1->R2, R3, R4
        ADD     R1, R2, R3
-       ADD     R(1)<<R(2), R(3), R(4)
+       ADD     R(1)<<R(2), R(3), R(4) // ADD   R1<<R2, R3, R4
 
 //     LTYPE1 cond imsr ',' spreg ',' // asm doesn't support trailing comma.
 //     {
@@ -65,15 +65,16 @@ TEXT        foo(SB), 0, $0
 //     {
 //             outcode($1, $2, &nullgen, 0, &$4);
 //     }
-       B.S     1(PC)
+       B.EQ    1(PC) // BEQ 1(PC)
 
 //     LTYPE4 cond comma nireg
 //     {
 //             outcode($1, $2, &nullgen, 0, &$4);
 //     }
-       B.S     (R2)
-       B.S     foo(SB)
-       B.S     bar<>(SB)
+       BEQ     2(PC)
+       B       foo(SB) // JMP foo(SB)
+       BEQ     2(PC)
+       B       bar<>(SB) // JMP bar<>(SB)
 
 //
 // BX
@@ -82,7 +83,7 @@ TEXT  foo(SB), 0, $0
 //     {
 //             outcode($1, Always, &nullgen, 0, &$3);
 //     }
-       BX      (R2)
+       BX      (R0)
 
 //
 // BEQ
@@ -100,9 +101,9 @@ TEXT        foo(SB), 0, $0
 //     {
 //             outcode($1, $2, &nullgen, 0, &$4);
 //     }
-       SWI.S   R1
+       SWI.S   $2
        SWI.S   (R1)
-       SWI.S   foo(SB)
+//     SWI.S   foo(SB) - TODO: classifying foo(SB) as C_TLS_LE
 
 //
 // CMP
@@ -127,8 +128,8 @@ TEXT        foo(SB), 0, $0
 //             g.Offset = int64($6);
 //             outcode($1, $2, &$3, 0, &g);
 //     }
-       MOVM    0(R1), [R2,R5,R8,g]
-       MOVM    0(R1), [R2-R5]
+       MOVM    0(R1), [R2,R5,R8,g] // MOVM     (R1), [R2,R5,R8,g]
+       MOVM    (R1), [R2-R5] // MOVM (R1), [R2,R3,R4,R5]
        MOVM.S  (R1), [R2]
 
 //     LTYPE8 cond '[' reglist ']' ',' ioreg
@@ -140,8 +141,8 @@ TEXT        foo(SB), 0, $0
 //             g.Offset = int64($4);
 //             outcode($1, $2, &g, 0, &$7);
 //     }
-       MOVM    [R2,R5,R8,g], 0(R1)
-       MOVM    [R2-R5], 0(R1)
+       MOVM    [R2,R5,R8,g], 0(R1) // MOVM     [R2,R5,R8,g], (R1)
+       MOVM    [R2-R5], (R1) // MOVM [R2,R3,R4,R5], (R1)
        MOVM.S  [R2], (R1)
 
 //
@@ -151,19 +152,19 @@ TEXT      foo(SB), 0, $0
 //     {
 //             outcode($1, $2, &$5, int32($3.Reg), &$7);
 //     }
-       STREX.S R1, (R2), R3
+       STREX.S R1, (R2), R3 // STREX.S (R2), R1, R3
 
 //     LTYPE9 cond reg ',' ireg
 //     {
 //             outcode($1, $2, &$5, int32($3.Reg), &$3);
 //     }
-       STREX.S R1, (R2)
+       STREX.S R1, (R2) // STREX.S (R2), R1, R1
 
 //     LTYPE9 cond comma ireg ',' reg
 //     {
 //             outcode($1, $2, &$4, int32($6.Reg), &$6);
 //     }
-       STREX.S (R2), R3
+       STREX.S (R2), R3 // STREX.S (R2), R3, R3
 
 //
 // word
@@ -188,14 +189,13 @@ TEXT      foo(SB), 0, $0
 //             outcode($1, $2, &$3, 0, &$5);
 //     }
        ADDD.S  F1, F2
-       ADDD.S  $0.5, F2
+       MOVF    $0.5, F2 // MOVF $(0.5), F2
 
 //     LTYPEK cond frcon ',' LFREG ',' freg
 //     {
 //             outcode($1, $2, &$3, $5, &$7);
 //     }
        ADDD.S  F1, F2, F3
-       ADDD.S  $0.5, F2, F3
 
 //     LTYPEL cond freg ',' freg
 //     {
@@ -225,8 +225,8 @@ TEXT        foo(SB), 0, $0
 //                     (1<<4));                        /* must be set */
 //             outcode(AMRC, Always, &nullgen, 0, &g);
 //     }
-       MRC.S   4, 6, R1, C2, C3, 7
-       MCR.S   4, 6, R1, C2, C3, 7
+       MRC.S   4, 6, R1, C2, C3, 7 // MRC $8301712627
+       MCR.S   4, 6, R1, C2, C3, 7 // MRC $8300664051
 
 //
 // MULL r1,r2,(hi,lo)
@@ -265,12 +265,15 @@ TEXT      foo(SB), 0, $0
 //     {
 //             outcode($1, $2, &nullgen, 0, &nullgen);
 //     }
+       BEQ     2(PC)
        RET
 
 // More B/BL cases, and canonical names JMP, CALL.
 
-       B       foo(SB)
-       BL      foo(SB)
+       BEQ     2(PC)
+       B       foo(SB) // JMP foo(SB)
+       BL      foo(SB) // CALL foo(SB)
+       BEQ     2(PC)
        JMP     foo(SB)
        CALL    foo(SB)
 

diff --git a/src/cmd/asm/internal/asm/testdata/arm64.out b/src/cmd/asm/internal/asm/testdata/arm64.out
deleted file mode 100644 (file)
index 37944bc..0000000
--- a/src/cmd/asm/internal/asm/testdata/arm64.out
+++ /dev/null
@@ -1,55 +0,0 @@
-9 00001 (testdata/arm64.s:9)   TEXT    foo(SB), 7, $-8
-20 00002 (testdata/arm64.s:20) ADDW    $1, R2, R3
-21 00003 (testdata/arm64.s:21) ADDW    R1, R2, R3
-22 00004 (testdata/arm64.s:22) ADDW    R1, ZR, R3
-23 00005 (testdata/arm64.s:23) ADD     $1, R2, R3
-24 00006 (testdata/arm64.s:24) ADD     R1, R2, R3
-25 00007 (testdata/arm64.s:25) ADD     R1, ZR, R3
-26 00008 (testdata/arm64.s:26) ADD     $1, R2, R3
-36 00009 (testdata/arm64.s:36) ADDW    $1, R2
-37 00010 (testdata/arm64.s:37) ADDW    R1, R2
-38 00011 (testdata/arm64.s:38) ADD     $1, R2
-39 00012 (testdata/arm64.s:39) ADD     R1, R2
-48 00013 (testdata/arm64.s:48) CLSW    R1, R2
-49 00014 (testdata/arm64.s:49) CLS     R1, R2
-58 00015 (testdata/arm64.s:58) MOVW    R1, R2
-59 00016 (testdata/arm64.s:59) MOVW    ZR, R1
-60 00017 (testdata/arm64.s:60) MOVW    R1, ZR
-61 00018 (testdata/arm64.s:61) MOVW    $1, ZR
-62 00019 (testdata/arm64.s:62) MOVW    $1, R1
-63 00020 (testdata/arm64.s:63) MOVW    ZR, (R1)
-64 00021 (testdata/arm64.s:64) MOVD    R1, R2
-65 00022 (testdata/arm64.s:65) MOVD    ZR, R1
-66 00023 (testdata/arm64.s:66) MOVD    $1, ZR
-67 00024 (testdata/arm64.s:67) MOVD    $1, R1
-68 00025 (testdata/arm64.s:68) MOVD    ZR, (R1)
-77 00026 (testdata/arm64.s:77) MOVK    $1, R1
-86 00027 (testdata/arm64.s:86) CALL    28(PC)
-92 00028 (testdata/arm64.s:92) CALL    (R2)
-93 00029 (testdata/arm64.s:93) CALL    foo(SB)
-94 00030 (testdata/arm64.s:94) CALL    bar<>(SB)
-102 00031 (testdata/arm64.s:102)       BEQ     32(PC)
-110 00032 (testdata/arm64.s:110)       SVC
-119 00033 (testdata/arm64.s:119)       CMP     $3, R2
-120 00034 (testdata/arm64.s:120)       CMP     R1, R2
-130 00035 (testdata/arm64.s:130)       CBZ     R1
-139 00036 (testdata/arm64.s:139)       CSET    GT, R1
-147 00037 (testdata/arm64.s:147)       CSEL    LT, R1, R2, ZR
-148 00038 (testdata/arm64.s:148)       CSINC   GT, R1, ZR, R3
-149 00039 (testdata/arm64.s:149)       CSNEG   MI, R1, R2, R3
-150 00040 (testdata/arm64.s:150)       CSINV   HS, R1, R2, R3
-156 00041 (testdata/arm64.s:156)       CSEL    LT, R1, R2
-164 00042 (testdata/arm64.s:164)       CCMN    MI, ZR, R1, $4
-173 00043 (testdata/arm64.s:173)       FADDD   $(0.5), F1
-174 00044 (testdata/arm64.s:174)       FADDD   F1, F2
-180 00045 (testdata/arm64.s:180)       FADDD   $(0.69999999999999996), F1, F2
-181 00046 (testdata/arm64.s:181)       FADDD   F1, F2, F3
-233 00047 (testdata/arm64.s:233)       DMB     $1
-242 00048 (testdata/arm64.s:242)       LDAXRW  (R0), R2
-243 00049 (testdata/arm64.s:243)       STLXRW  R1, (R0), R3
-251 00050 (testdata/arm64.s:251)       RET
-255 00051 (testdata/arm64.s:255)       JMP     foo(SB)
-256 00052 (testdata/arm64.s:256)       CALL    foo(SB)
-257 00053 (testdata/arm64.s:257)       JMP     foo(SB)
-258 00054 (testdata/arm64.s:258)       CALL    foo(SB)
-266 00055 (testdata/arm64.s:266)       END

diff --git a/src/cmd/asm/internal/asm/testdata/arm64.s b/src/cmd/asm/internal/asm/testdata/arm64.s
index 2c8720bd3b9511389597a91d155497441e7fbca5..22d430631cf06735174a1d28a972038a18366856 100644 (file)
--- a/src/cmd/asm/internal/asm/testdata/arm64.s
+++ b/src/cmd/asm/internal/asm/testdata/arm64.s
@@ -83,15 +83,15 @@ TEXT        foo(SB), 7, $-8
 //     {
 //             outcode($1, &nullgen, NREG, &$3);
 //     }
-       BL      1(PC)
+       BL      1(PC) // CALL 1(PC)
 
 //             LTYPE4 comma nireg
 //     {
 //             outcode($1, &nullgen, NREG, &$3);
 //     }
-       BL      (R2)
-       BL      foo(SB)
-       BL      bar<>(SB)
+       BL      (R2) // CALL (R2)
+       BL      foo(SB) // CALL foo(SB)
+       BL      bar<>(SB) // CALL bar<>(SB)
 //
 // BEQ
 //
@@ -127,7 +127,7 @@ TEXT        foo(SB), 7, $-8
 //             outcode($1, &$2, NREG, &$4);
 //     }
 again:
-       CBZ     R1, again
+       CBZ     R1, again // CBZ R1
 
 //
 // CSET
@@ -147,7 +147,7 @@ again:
        CSEL    LT, R1, R2, ZR
        CSINC   GT, R1, ZR, R3
        CSNEG   MI, R1, R2, R3
-       CSINV   CS, R1, R2, R3
+       CSINV   CS, R1, R2, R3 // CSINV HS, R1, R2, R3
 
 //             LTYPES cond ',' reg ',' reg
 //     {
@@ -170,14 +170,14 @@ again:
 //     {
 //             outcode($1, &$2, NREG, &$4);
 //     }
-       FADDD   $0.5, F1
+       FADDD   $0.5, F1 // FADDD $(0.5), F1
        FADDD   F1, F2
 
 //             LTYPEK frcon ',' freg ',' freg
 //     {
 //             outcode($1, &$2, $4.reg, &$6);
 //     }
-       FADDD   $0.7, F1, F2
+       FADDD   $0.7, F1, F2 // FADDD   $(0.69999999999999996), F1, F2
        FADDD   F1, F2, F3
 
 //
@@ -248,12 +248,15 @@ again:
 //     {
 //             outcode($1, &nullgen, NREG, &nullgen);
 //     }
+       BEQ     2(PC)
        RET
 
 // More B/BL cases, and canonical names JMP, CALL.
 
-       B       foo(SB)
-       BL      foo(SB)
+       BEQ     2(PC)
+       B       foo(SB) // JMP foo(SB)
+       BL      foo(SB) // CALL foo(SB)
+       BEQ     2(PC)
        JMP     foo(SB)
        CALL    foo(SB)
 

diff --git a/src/cmd/asm/internal/asm/testdata/mips64.out b/src/cmd/asm/internal/asm/testdata/mips64.out
deleted file mode 100644 (file)
index 9263a7b..0000000
--- a/src/cmd/asm/internal/asm/testdata/mips64.out
+++ /dev/null
@@ -1,99 +0,0 @@
-8 00001 (testdata/mips64.s:8)  TEXT    foo(SB), 0, $0
-18 00002 (testdata/mips64.s:18)        MOVW    R1, R2
-19 00003 (testdata/mips64.s:19)        MOVW    LO, R1
-20 00004 (testdata/mips64.s:20)        MOVW    HI, R1
-21 00005 (testdata/mips64.s:21)        MOVW    R1, LO
-22 00006 (testdata/mips64.s:22)        MOVW    R1, HI
-23 00007 (testdata/mips64.s:23)        MOVV    R1, R2
-24 00008 (testdata/mips64.s:24)        MOVV    LO, R1
-25 00009 (testdata/mips64.s:25)        MOVV    HI, R1
-26 00010 (testdata/mips64.s:26)        MOVV    R1, LO
-27 00011 (testdata/mips64.s:27)        MOVV    R1, HI
-33 00012 (testdata/mips64.s:33)        MOVW    foo<>+3(SB), R2
-34 00013 (testdata/mips64.s:34)        MOVW    16(R1), R2
-35 00014 (testdata/mips64.s:35)        MOVW    (R1), R2
-36 00015 (testdata/mips64.s:36)        MOVV    foo<>+3(SB), R2
-37 00016 (testdata/mips64.s:37)        MOVV    16(R1), R2
-38 00017 (testdata/mips64.s:38)        MOVV    (R1), R2
-44 00018 (testdata/mips64.s:44)        MOVB    R1, R2
-50 00019 (testdata/mips64.s:50)        MOVB    foo<>+3(SB), R2
-51 00020 (testdata/mips64.s:51)        MOVB    16(R1), R2
-52 00021 (testdata/mips64.s:52)        MOVB    (R1), R2
-61 00022 (testdata/mips64.s:61)        MOVD    foo<>+3(SB), F2
-62 00023 (testdata/mips64.s:62)        MOVD    16(R1), F2
-63 00024 (testdata/mips64.s:63)        MOVD    (R1), F2
-69 00025 (testdata/mips64.s:69)        MOVD    $(0.10000000000000001), F2
-75 00026 (testdata/mips64.s:75)        MOVD    F1, F2
-81 00027 (testdata/mips64.s:81)        MOVD    F2, foo<>+3(SB)
-82 00028 (testdata/mips64.s:82)        MOVD    F2, 16(R1)
-83 00029 (testdata/mips64.s:83)        MOVD    F2, (R1)
-92 00030 (testdata/mips64.s:92)        MOVW    R1, foo<>+3(SB)
-93 00031 (testdata/mips64.s:93)        MOVW    R1, 16(R2)
-94 00032 (testdata/mips64.s:94)        MOVW    R1, (R2)
-95 00033 (testdata/mips64.s:95)        MOVV    R1, foo<>+3(SB)
-96 00034 (testdata/mips64.s:96)        MOVV    R1, 16(R2)
-97 00035 (testdata/mips64.s:97)        MOVV    R1, (R2)
-103 00036 (testdata/mips64.s:103)      MOVB    R1, foo<>+3(SB)
-104 00037 (testdata/mips64.s:104)      MOVB    R1, 16(R2)
-105 00038 (testdata/mips64.s:105)      MOVB    R1, (R2)
-114 00039 (testdata/mips64.s:114)      MOVD    F1, foo<>+3(SB)
-115 00040 (testdata/mips64.s:115)      MOVD    F1, 16(R2)
-116 00041 (testdata/mips64.s:116)      MOVD    F1, (R2)
-125 00042 (testdata/mips64.s:125)      MOVW    FCR0, R1
-131 00043 (testdata/mips64.s:131)      MOVW    R1, FCR0
-137 00044 (testdata/mips64.s:137)      MOVW    R1, M1
-138 00045 (testdata/mips64.s:138)      MOVV    R1, M1
-144 00046 (testdata/mips64.s:144)      MOVW    M1, R1
-145 00047 (testdata/mips64.s:145)      MOVV    M1, R1
-158 00048 (testdata/mips64.s:158)      ADD     R1, R2, R3
-164 00049 (testdata/mips64.s:164)      ADD     $1, R2, R3
-170 00050 (testdata/mips64.s:170)      ADD     R1, R2
-176 00051 (testdata/mips64.s:176)      ADD     $4, R1
-182 00052 (testdata/mips64.s:182)      MUL     R1, R2
-188 00053 (testdata/mips64.s:188)      SLL     R1, R2, R3
-194 00054 (testdata/mips64.s:194)      SLL     R1, R2
-200 00055 (testdata/mips64.s:200)      SLL     $4, R1, R2
-206 00056 (testdata/mips64.s:206)      SLL     $4, R1
-215 00057 (testdata/mips64.s:215)      MOVW    $1, R1
-216 00058 (testdata/mips64.s:216)      MOVV    $1, R1
-222 00059 (testdata/mips64.s:222)      MOVW    $1, R1
-223 00060 (testdata/mips64.s:223)      MOVW    $foo(SB), R1
-224 00061 (testdata/mips64.s:224)      MOVV    $1, R1
-225 00062 (testdata/mips64.s:225)      MOVV    $foo(SB), R1
-236 00063 (testdata/mips64.s:236)      JMP     64(PC)
-237 00064 (testdata/mips64.s:237)      JMP     63
-238 00065 (testdata/mips64.s:238)      CALL    66(PC)
-239 00066 (testdata/mips64.s:239)      CALL    63
-245 00067 (testdata/mips64.s:245)      JMP     4(R1)
-246 00068 (testdata/mips64.s:246)      JMP     foo(SB)
-247 00069 (testdata/mips64.s:247)      CALL    4(R1)
-248 00070 (testdata/mips64.s:248)      CALL    foo(SB)
-258 00071 (testdata/mips64.s:258)      BEQ     R1, 72(PC)
-259 00072 (testdata/mips64.s:259)      BEQ     R1, 71
-266 00073 (testdata/mips64.s:266)      BEQ     R1, R2, 74(PC)
-267 00074 (testdata/mips64.s:267)      BEQ     R1, R2, 73
-277 00075 (testdata/mips64.s:277)      BLTZ    R1, 76(PC)
-278 00076 (testdata/mips64.s:278)      BLTZ    R1, 75
-285 00077 (testdata/mips64.s:285)      BFPT    78(PC)
-286 00078 (testdata/mips64.s:286)      BFPT    77
-296 00079 (testdata/mips64.s:296)      ABSD    F1, F2
-302 00080 (testdata/mips64.s:302)      ADDD    F1, F2
-308 00081 (testdata/mips64.s:308)      ADDD    F1, F2, F3
-314 00082 (testdata/mips64.s:314)      CMPEQD  F1, F2
-320 00083 (testdata/mips64.s:320)      WORD    $1
-321 00084 (testdata/mips64.s:321)      WORD    $foo(SB)
-330 00085 (testdata/mips64.s:330)      NOP
-336 00086 (testdata/mips64.s:336)      NOP     R2
-342 00087 (testdata/mips64.s:342)      NOP     F2
-348 00088 (testdata/mips64.s:348)      NOP     R2
-354 00089 (testdata/mips64.s:354)      NOP     F2
-360 00090 (testdata/mips64.s:360)      NOP     $4
-365 00091 (testdata/mips64.s:365)      SYSCALL
-366 00092 (testdata/mips64.s:366)      BREAK
-367 00093 (testdata/mips64.s:367)      BREAK   $1, (R1)
-376 00094 (testdata/mips64.s:376)      SYSCALL
-377 00095 (testdata/mips64.s:377)      RET
-382 00096 (testdata/mips64.s:382)      CALL    foo(SB)
-383 00097 (testdata/mips64.s:383)      JMP     foo(SB)
-384 00098 (testdata/mips64.s:384)      CALL    foo(SB)
-392 00099 (testdata/mips64.s:392)      END

diff --git a/src/cmd/asm/internal/asm/testdata/mips64.s b/src/cmd/asm/internal/asm/testdata/mips64.s
index 4112b4b1201a035e0d0bef9b1480a389cf8c3c53..12330a2edb9d360115e6aa94d82038734eefd583 100644 (file)
--- a/src/cmd/asm/internal/asm/testdata/mips64.s
+++ b/src/cmd/asm/internal/asm/testdata/mips64.s
@@ -5,7 +5,7 @@
 // This input was created by taking the ppc64 testcase and modified
 // by hand.
 
-TEXT foo(SB),0,$0
+TEXT foo(SB),7,$0
 
 //inst:
 //
@@ -66,7 +66,7 @@ TEXT foo(SB),0,$0
 //     {
 //             outcode(int($1), &$2, 0, &$4);
 //     }
-       MOVD    $0.1, F2
+       MOVD    $0.1, F2 // MOVD $(0.10000000000000001), F2
 
 //     LFMOV freg ',' freg
 //     {
@@ -232,20 +232,28 @@ TEXT foo(SB),0,$0
 //     {
 //             outcode(int($1), &nullgen, 0, &$2);
 //     }
+       BEQ     R1, 2(PC)
 label0:
        JMP     1(PC)
-       JMP     label0+0
-       JAL     1(PC)
-       JAL     label0+0
+       BEQ     R1, 2(PC)
+       JMP     label0+0 // JMP 64
+       BEQ     R1, 2(PC)
+       JAL     1(PC) // CALL 1(PC)
+       BEQ     R1, 2(PC)
+       JAL     label0+0 // CALL 64
 
 //     LBRA addr
 //     {
 //             outcode(int($1), &nullgen, 0, &$2);
 //     }
-       JMP     4(R1)
-       JMP     foo+0(SB)
-       JAL     4(R1)
-       JAL     foo+0(SB)
+       BEQ     R1, 2(PC)
+       JMP     0(R1) // JMP (R1)
+       BEQ     R1, 2(PC)
+       JMP     foo+0(SB) // JMP foo(SB)
+       BEQ     R1, 2(PC)
+       JAL     0(R1) // CALL (R1)
+       BEQ     R1, 2(PC)
+       JAL     foo+0(SB) // CALL foo(SB)
 
 //
 // BEQ/BNE
@@ -256,7 +264,7 @@ label0:
 //     }
 label1:
        BEQ     R1, 1(PC)
-       BEQ     R1, label1
+       BEQ     R1, label1 // BEQ R1, 79
 
 //     LBRA rreg ',' sreg ',' rel
 //     {
@@ -264,7 +272,7 @@ label1:
 //     }
 label2:
        BEQ     R1, R2, 1(PC)
-       BEQ     R1, R2, label2
+       BEQ     R1, R2, label2 // BEQ R1, R2, 81
 
 //
 // other integer conditional branch
@@ -275,7 +283,7 @@ label2:
 //     }
 label3:
        BLTZ    R1, 1(PC)
-       BLTZ    R1, label3
+       BLTZ    R1, label3 // BLTZ R1, 83
 
 //
 // floating point conditional branch
@@ -283,7 +291,7 @@ label3:
 //     LBRA rel
 label4:
        BFPT    1(PC)
-       BFPT    label4
+       BFPT    label4 // BFPT 85
 
 
 //
@@ -364,7 +372,8 @@ label4:
 //
        SYSCALL
        BREAK
-       BREAK   $1, (R1) // overloaded CACHE opcode
+       // overloaded cache opcode:
+       BREAK   R1, (R1)
 
 //
 // RET
@@ -374,12 +383,14 @@ label4:
 //             outcode(int($1), &nullgen, 0, &nullgen);
 //     }
        SYSCALL
+       BEQ     R1, 2(PC)
        RET
 
 
 // More JMP/JAL cases, and canonical names JMP, CALL.
 
-       JAL     foo(SB)
+       JAL     foo(SB) // CALL foo(SB)
+       BEQ     R1, 2(PC)
        JMP     foo(SB)
        CALL    foo(SB)
 

diff --git a/src/cmd/asm/internal/asm/testdata/ppc64.out b/src/cmd/asm/internal/asm/testdata/ppc64.out
deleted file mode 100644 (file)
index 2a5d175..0000000
--- a/src/cmd/asm/internal/asm/testdata/ppc64.out
+++ /dev/null
@@ -1,114 +0,0 @@
-9 00001 (testdata/ppc64.s:9)   TEXT    foo(SB), 0, $0
-19 00002 (testdata/ppc64.s:19) MOVW    R1, R2
-25 00003 (testdata/ppc64.s:25) MOVW    foo<>+3(SB), R2
-26 00004 (testdata/ppc64.s:26) MOVW    16(R1), R2
-32 00005 (testdata/ppc64.s:32) MOVW    (R1), R2
-33 00006 (testdata/ppc64.s:33) MOVW    (R1)(R2*1), R3
-39 00007 (testdata/ppc64.s:39) MOVW    R1, R2
-45 00008 (testdata/ppc64.s:45) MOVB    foo<>+3(SB), R2
-46 00009 (testdata/ppc64.s:46) MOVB    16(R1), R2
-52 00010 (testdata/ppc64.s:52) MOVB    (R1), R2
-53 00011 (testdata/ppc64.s:53) MOVB    (R1)(R2*1), R3
-62 00012 (testdata/ppc64.s:62) FMOVD   foo<>+3(SB), F2
-63 00013 (testdata/ppc64.s:63) FMOVD   16(R1), F2
-69 00014 (testdata/ppc64.s:69) FMOVD   (R1), F2
-75 00015 (testdata/ppc64.s:75) FMOVD   $(0.10000000000000001), F2
-81 00016 (testdata/ppc64.s:81) FMOVD   F1, F2
-87 00017 (testdata/ppc64.s:87) FMOVD   F2, foo<>+3(SB)
-88 00018 (testdata/ppc64.s:88) FMOVD   F2, 16(R1)
-94 00019 (testdata/ppc64.s:94) FMOVD   F2, (R1)
-103 00020 (testdata/ppc64.s:103)       MOVW    R1, foo<>+3(SB)
-104 00021 (testdata/ppc64.s:104)       MOVW    R1, 16(R2)
-110 00022 (testdata/ppc64.s:110)       MOVW    R1, (R1)
-111 00023 (testdata/ppc64.s:111)       MOVW    R1, (R2)(R3*1)
-117 00024 (testdata/ppc64.s:117)       MOVB    R1, foo<>+3(SB)
-118 00025 (testdata/ppc64.s:118)       MOVB    R1, 16(R2)
-124 00026 (testdata/ppc64.s:124)       MOVB    R1, (R1)
-125 00027 (testdata/ppc64.s:125)       MOVB    R1, (R2)(R3*1)
-133 00028 (testdata/ppc64.s:133)       FMOVD   F1, foo<>+3(SB)
-134 00029 (testdata/ppc64.s:134)       FMOVD   F1, 16(R2)
-140 00030 (testdata/ppc64.s:140)       FMOVD   F1, (R1)
-149 00031 (testdata/ppc64.s:149)       MOVFL   FPSCR, F1
-155 00032 (testdata/ppc64.s:155)       MOVFL   F1, FPSCR
-161 00033 (testdata/ppc64.s:161)       MOVFL   F1, $4, FPSCR
-167 00034 (testdata/ppc64.s:167)       MOVFL   FPSCR, CR0
-188 00035 (testdata/ppc64.s:188)       MOVW    R1, CR1
-194 00036 (testdata/ppc64.s:194)       MOVW    R1, CR
-206 00037 (testdata/ppc64.s:206)       ADD     R1, R2, R3
-212 00038 (testdata/ppc64.s:212)       ADD     $1, R2, R3
-224 00039 (testdata/ppc64.s:224)       ADD     R1, R2
-230 00040 (testdata/ppc64.s:230)       ADD     $4, R1
-236 00041 (testdata/ppc64.s:236)       ADDE    R1, R2, R3
-242 00042 (testdata/ppc64.s:242)       ADDE    R1, R2
-248 00043 (testdata/ppc64.s:248)       SLW     R1, R2, R3
-254 00044 (testdata/ppc64.s:254)       SLW     R1, R2
-260 00045 (testdata/ppc64.s:260)       SLW     $4, R1, R2
-266 00046 (testdata/ppc64.s:266)       SLW     $4, R1
-272 00047 (testdata/ppc64.s:272)       SLW     $4, R1
-278 00048 (testdata/ppc64.s:278)       SUBME   R1, R1
-296 00049 (testdata/ppc64.s:296)       MOVW    $1, R1
-302 00050 (testdata/ppc64.s:302)       MOVW    $1, R1
-303 00051 (testdata/ppc64.s:303)       MOVW    $foo(SB), R1
-327 00052 (testdata/ppc64.s:327)       MOVFL   CR0, CR1
-339 00053 (testdata/ppc64.s:339)       MOVW    CR, R1
-345 00054 (testdata/ppc64.s:345)       MOVW    SPR(0), R1
-346 00055 (testdata/ppc64.s:346)       MOVW    SPR(7), R1
-352 00056 (testdata/ppc64.s:352)       MOVW    LR, R1
-353 00057 (testdata/ppc64.s:353)       MOVW    CTR, R1
-359 00058 (testdata/ppc64.s:359)       MOVW    R1, LR
-360 00059 (testdata/ppc64.s:360)       MOVW    R1, CTR
-372 00060 (testdata/ppc64.s:372)       MOVW    R1, SPR(7)
-384 00061 (testdata/ppc64.s:384)       JMP     62(PC)
-385 00062 (testdata/ppc64.s:385)       JMP     61
-391 00063 (testdata/ppc64.s:391)       JMP     4(R1)
-392 00064 (testdata/ppc64.s:392)       JMP     foo(SB)
-398 00065 (testdata/ppc64.s:398)       JMP     CTR
-417 00066 (testdata/ppc64.s:417)       BEQ     CR1, 67(PC)
-418 00067 (testdata/ppc64.s:418)       BEQ     CR1, 66
-444 00068 (testdata/ppc64.s:444)       BC      4, CTR
-454 00069 (testdata/ppc64.s:454)       BC      $3, R4, 66
-474 00070 (testdata/ppc64.s:474)       BC      $3, R3, LR
-504 00071 (testdata/ppc64.s:504)       FABS    F1, F2
-510 00072 (testdata/ppc64.s:510)       FADD    F1, F2
-516 00073 (testdata/ppc64.s:516)       FADD    F1, F2, F3
-522 00074 (testdata/ppc64.s:522)       FMADD   F1, F2, F3, F4
-528 00075 (testdata/ppc64.s:528)       FCMPU   F1, F2
-534 00076 (testdata/ppc64.s:534)       FCMPU   F1, F2, CR0
-543 00077 (testdata/ppc64.s:543)       CMP     R1, R2
-549 00078 (testdata/ppc64.s:549)       CMP     R1, $4
-555 00079 (testdata/ppc64.s:555)       CMP     R1, CR0, R2
-561 00080 (testdata/ppc64.s:561)       CMP     R1, CR0, $4
-570 00081 (testdata/ppc64.s:570)       RLDC    $4, R1, $5, R2
-576 00082 (testdata/ppc64.s:576)       RLDC    $26, R1, $201326592, R2
-582 00083 (testdata/ppc64.s:582)       RLDC    R1, R2, $4, R3
-588 00084 (testdata/ppc64.s:588)       RLWMI   R1, R2, $201326592, R3
-597 00085 (testdata/ppc64.s:597)       MOVMW   foo(SB), R2
-598 00086 (testdata/ppc64.s:598)       MOVMW   4(R1), R2
-604 00087 (testdata/ppc64.s:604)       MOVMW   R1, foo(SB)
-605 00088 (testdata/ppc64.s:605)       MOVMW   R1, 4(R2)
-615 00089 (testdata/ppc64.s:615)       LSW     (R1), R2
-616 00090 (testdata/ppc64.s:616)       LSW     (R1)(R2*1), R3
-622 00091 (testdata/ppc64.s:622)       LSW     (R1), $1, R2
-623 00092 (testdata/ppc64.s:623)       LSW     (R1)(R2*1), $1, R3
-629 00093 (testdata/ppc64.s:629)       STSW    R1, (R2)
-630 00094 (testdata/ppc64.s:630)       STSW    R1, (R2)(R3*1)
-636 00095 (testdata/ppc64.s:636)       STSW    R1, $1, (R2)
-637 00096 (testdata/ppc64.s:637)       STSW    R1, $1, (R2)(R3*1)
-643 00097 (testdata/ppc64.s:643)       MOVHBR  (R1), R2
-644 00098 (testdata/ppc64.s:644)       MOVHBR  (R1)(R2*1), R3
-650 00099 (testdata/ppc64.s:650)       MOVHBR  R1, (R2)
-651 00100 (testdata/ppc64.s:651)       MOVHBR  R1, (R2)(R3*1)
-657 00101 (testdata/ppc64.s:657)       DCBF    (R1)
-658 00102 (testdata/ppc64.s:658)       DCBF    (R1)(R2*1)
-667 00103 (testdata/ppc64.s:667)       NOP
-673 00104 (testdata/ppc64.s:673)       NOP     R2
-679 00105 (testdata/ppc64.s:679)       NOP     F2
-685 00106 (testdata/ppc64.s:685)       NOP     R2
-691 00107 (testdata/ppc64.s:691)       NOP     F2
-697 00108 (testdata/ppc64.s:697)       NOP     $4
-705 00109 (testdata/ppc64.s:705)       RET
-709 00110 (testdata/ppc64.s:709)       JMP     foo(SB)
-710 00111 (testdata/ppc64.s:710)       CALL    foo(SB)
-711 00112 (testdata/ppc64.s:711)       JMP     foo(SB)
-712 00113 (testdata/ppc64.s:712)       CALL    foo(SB)
-720 00114 (testdata/ppc64.s:720)       END

diff --git a/src/cmd/asm/internal/asm/testdata/ppc64.s b/src/cmd/asm/internal/asm/testdata/ppc64.s
index 46c1ee6d95d9d7b6b08c8125b91a4ec49e8c8519..c46c6b2f5a5d1a3e13838abb4ee67f8161114bad 100644 (file)
--- a/src/cmd/asm/internal/asm/testdata/ppc64.s
+++ b/src/cmd/asm/internal/asm/testdata/ppc64.s
@@ -6,7 +6,7 @@
 // the old assembler's (9a's) grammar and hand-writing complete
 // instructions for each rule, to guarantee we cover the same space.
 
-TEXT foo(SB),0,$0
+TEXT foo(SB),7,$0
 
 //inst:
 //
@@ -30,7 +30,7 @@ TEXT foo(SB),0,$0
 //             outcode(int($1), &$2, 0, &$4);
 //     }
        MOVW    (R1), R2
-       MOVW    (R1+R2), R3
+       MOVW    (R1+R2), R3 // MOVW (R1)(R2*1), R3
 
 //     LMOVB rreg ',' rreg
 //     {
@@ -50,7 +50,7 @@ TEXT foo(SB),0,$0
 //             outcode(int($1), &$2, 0, &$4);
 //     }
        MOVB    (R1), R2
-       MOVB    (R1+R2), R3
+       MOVB    (R1+R2), R3 // MOVB (R1)(R2*1), R3
 
 //
 // load floats
@@ -72,7 +72,7 @@ TEXT foo(SB),0,$0
 //     {
 //             outcode(int($1), &$2, 0, &$4);
 //     }
-       FMOVD   $0.1, F2
+       FMOVD   $0.1, F2 // FMOVD $(0.10000000000000001), F2
 
 //     LFMOV freg ',' freg
 //     {
@@ -108,7 +108,7 @@ TEXT foo(SB),0,$0
 //             outcode(int($1), &$2, 0, &$4);
 //     }
        MOVW    R1, (R1)
-       MOVW    R1, (R2+R3)
+       MOVW    R1, (R2+R3) // MOVW R1, (R2)(R3*1)
 
 //     LMOVB rreg ',' addr
 //     {
@@ -122,7 +122,7 @@ TEXT foo(SB),0,$0
 //             outcode(int($1), &$2, 0, &$4);
 //     }
        MOVB    R1, (R1)
-       MOVB    R1, (R2+R3)
+       MOVB    R1, (R2+R3) // MOVB R1, (R2)(R3*1)
 //
 // store floats
 //
@@ -275,7 +275,7 @@ TEXT foo(SB),0,$0
 //     {
 //             outcode(int($1), &$2, 0, &$2);
 //     }
-       SUBME   R1
+       SUBME   R1 // SUBME R1, R1
 
 //
 // multiply-accumulate
@@ -380,22 +380,29 @@ TEXT foo(SB),0,$0
 //     {
 //             outcode(int($1), &nullgen, 0, &$2);
 //     }
+       BEQ     CR1, 2(PC)
 label0:
-       BR      1(PC)
-       BR      label0+0
+       BR      1(PC) // JMP 1(PC)
+       BEQ     CR1, 2(PC)
+       BR      label0+0 // JMP 62
 
 //     LBRA addr
 //     {
 //             outcode(int($1), &nullgen, 0, &$2);
 //     }
-       BR      4(R1)
-       BR      foo+0(SB)
+       BEQ     CR1, 2(PC)
+       BR      LR // JMP LR
+       BEQ     CR1, 2(PC)
+//     BR      0(R1)   // TODO should work
+       BEQ     CR1, 2(PC)
+       BR      foo+0(SB) // JMP foo(SB)
 
 //     LBRA '(' xlreg ')'
 //     {
 //             outcode(int($1), &nullgen, 0, &$3);
 //     }
-       BR      (CTR)
+       BEQ     CR1, 2(PC)
+       BR      (CTR) // JMP CTR
 
 //     LBRA ',' rel  // asm doesn't support the leading comma
 //     {
@@ -415,7 +422,7 @@ label0:
 //     }
 label1:
        BEQ     CR1, 1(PC)
-       BEQ     CR1, label1
+       BEQ     CR1, label1 // BEQ CR1, 72
 
 //     LBRA creg ',' addr // TODO DOES NOT WORK in 9a
 //     {
@@ -441,7 +448,7 @@ label1:
 //     {
 //             outcode(int($1), &nullgen, int($2), &$5);
 //     }
-       BC      4, (CTR)
+//     BC      4, (CTR)        // TODO - should work
 
 //     LBRA con ',' con ',' rel
 //     {
@@ -451,7 +458,7 @@ label1:
 //             g.Offset = $2;
 //             outcode(int($1), &g, int(REG_R0+$4), &$6);
 //     }
-       BC      3, 4, label1
+//     BC      3, 4, label1 // TODO - should work
 
 //     LBRA con ',' con ',' addr // TODO mystery
 //     {
@@ -471,7 +478,7 @@ label1:
 //             g.Offset = $2;
 //             outcode(int($1), &g, int(REG_R0+$4), &$7);
 //     }
-       BC      3, 3, (LR)
+       BC      3, 3, (LR) // BC $3, R3, LR
 
 //
 // conditional trap // TODO NOT DEFINED
@@ -531,7 +538,7 @@ label1:
 //     {
 //             outcode(int($1), &$2, int($6.Reg), &$4);
 //     }
-       FCMPU   F1, F2, CR0
+//     FCMPU   F1, F2, CR0
 
 //
 // CMP
@@ -552,13 +559,13 @@ label1:
 //     {
 //             outcode(int($1), &$2, int($6.Reg), &$4);
 //     }
-       CMP     R1, R2, CR0
+       CMP     R1, R2, CR0 // CMP R1, CR0, R2
 
 //     LCMP rreg ',' imm ',' creg
 //     {
 //             outcode(int($1), &$2, int($6.Reg), &$4);
 //     }
-       CMP     R1, $4, CR0
+       CMP     R1, $4, CR0 // CMP R1, CR0, $4
 
 //
 // rotate and mask
@@ -567,25 +574,25 @@ label1:
 //     {
 //             outgcode(int($1), &$2, int($4.Reg), &$6, &$8);
 //     }
-       RLDC $4, R1, $5, R2
+       RLDC $4, R1, $16, R2
 
 //     LRLWM  imm ',' rreg ',' mask ',' rreg
 //     {
 //             outgcode(int($1), &$2, int($4.Reg), &$6, &$8);
 //     }
-       RLDC $26, R1, 4, 5, R2
+       RLDC $26, R1, 4, 5, R2 // RLDC $26, R1, $201326592, R2
 
 //     LRLWM  rreg ',' rreg ',' imm ',' rreg
 //     {
 //             outgcode(int($1), &$2, int($4.Reg), &$6, &$8);
 //     }
-       RLDC    R1, R2, $4, R3
+       RLDCL   R1, R2, $7, R3
 
 //     LRLWM  rreg ',' rreg ',' mask ',' rreg
 //     {
 //             outgcode(int($1), &$2, int($4.Reg), &$6, &$8);
 //     }
-       RLWMI   R1, R2, 4, 5, R3
+       RLWMI   R1, R2, 4, 5, R3 // RLWMI       R1, R2, $201326592, R3
 
 //
 // load/store multiple
@@ -594,14 +601,14 @@ label1:
 //     {
 //             outcode(int($1), &$2, 0, &$4);
 //     }
-       MOVMW   foo+0(SB), R2
+//     MOVMW   foo+0(SB), R2 // TODO TLS broke this!
        MOVMW   4(R1), R2
 
 //     LMOVMW rreg ',' addr
 //     {
 //             outcode(int($1), &$2, 0, &$4);
 //     }
-       MOVMW   R1, foo+0(SB)
+//     MOVMW   R1, foo+0(SB) // TODO TLS broke this!
        MOVMW   R1, 4(R2)
 
 //
@@ -613,49 +620,49 @@ label1:
 //             outcode(int($1), &$2, 0, &$4);
 //     }
        LSW     (R1), R2
-       LSW     (R1+R2), R3
+       LSW     (R1+R2), R3 // LSW      (R1)(R2*1), R3
 
 //     LXLD regaddr ',' imm ',' rreg
 //     {
 //             outgcode(int($1), &$2, 0, &$4, &$6);
 //     }
        LSW     (R1), $1, R2
-       LSW     (R1+R2), $1, R3
+       LSW     (R1+R2), $1, R3 // LSW  (R1)(R2*1), $1, R3
 
 //     LXST rreg ',' regaddr
 //     {
 //             outcode(int($1), &$2, 0, &$4);
 //     }
        STSW    R1, (R2)
-       STSW    R1, (R2+R3)
+       STSW    R1, (R2+R3) // STSW     R1, (R2)(R3*1)
 
 //     LXST rreg ',' imm ',' regaddr
 //     {
 //             outgcode(int($1), &$2, 0, &$4, &$6);
 //     }
        STSW    R1, $1, (R2)
-       STSW    R1, $1, (R2+R3)
+       STSW    R1, $1, (R2+R3) // STSW R1, $1, (R2)(R3*1)
 
 //     LXMV regaddr ',' rreg
 //     {
 //             outcode(int($1), &$2, 0, &$4);
 //     }
        MOVHBR  (R1), R2
-       MOVHBR  (R1+R2), R3
+       MOVHBR  (R1+R2), R3 // MOVHBR   (R1)(R2*1), R3
 
 //     LXMV rreg ',' regaddr
 //     {
 //             outcode(int($1), &$2, 0, &$4);
 //     }
        MOVHBR  R1, (R2)
-       MOVHBR  R1, (R2+R3)
+       MOVHBR  R1, (R2+R3) // MOVHBR   R1, (R2)(R3*1)
 
 //     LXOP regaddr
 //     {
 //             outcode(int($1), &$2, 0, &nullgen);
 //     }
        DCBF    (R1)
-       DCBF    (R1+R2)
+       DCBF    (R1+R2) // DCBF (R1)(R2*1)
 
 //
 // NOP
@@ -702,12 +709,15 @@ label1:
 //     {
 //             outcode(int($1), &nullgen, 0, &nullgen);
 //     }
+       BEQ     2(PC)
        RET
 
 // More BR/BL cases, and canonical names JMP, CALL.
 
-       BR      foo(SB)
-       BL      foo(SB)
+       BEQ     2(PC)
+       BR      foo(SB) // JMP foo(SB)
+       BL      foo(SB) //  CALL foo(SB)
+       BEQ     2(PC)
        JMP     foo(SB)
        CALL    foo(SB)
 

diff --git a/src/cmd/asm/internal/flags/flags.go b/src/cmd/asm/internal/flags/flags.go
index 89bc6f3a8c2f33fe657c5b0037f4da409a80cb76..9f3c3bfc1da752209b44728f159684778eed2419 100644 (file)
--- a/src/cmd/asm/internal/flags/flags.go
+++ b/src/cmd/asm/internal/flags/flags.go
@@ -20,6 +20,7 @@ var (
        TrimPath   = flag.String("trimpath", "", "remove prefix from recorded source file paths")
        Shared     = flag.Bool("shared", false, "generate code that can be linked into a shared library")
        Dynlink    = flag.Bool("dynlink", false, "support references to Go symbols defined in other shared libraries")
+       AllErrors  = flag.Bool("e", false, "no limit on number of errors reported")
 )
 
 var (

diff --git a/src/cmd/asm/main.go b/src/cmd/asm/main.go
index db0e28e2e59862b00e186aa69a4c6428982ceb68..f48050c137871c7e73afab908a182dcad5d846fc 100644 (file)
--- a/src/cmd/asm/main.go
+++ b/src/cmd/asm/main.go
@@ -47,21 +47,28 @@ func main() {
        }
        ctxt.Bso = obj.Binitw(os.Stdout)
        defer ctxt.Bso.Flush()
-       ctxt.Diag = log.Fatalf
        output := obj.Binitw(fd)
        fmt.Fprintf(output, "go object %s %s %s\n", obj.Getgoos(), obj.Getgoarch(), obj.Getgoversion())
        fmt.Fprintf(output, "!\n")
 
        lexer := lex.NewLexer(flag.Arg(0), ctxt)
        parser := asm.NewParser(ctxt, architecture, lexer)
+       diag := false
+       ctxt.DiagFunc = func(format string, args ...interface{}) {
+               diag = true
+               log.Printf(format, args...)
+       }
        pList := obj.Linknewplist(ctxt)
        var ok bool
        pList.Firstpc, ok = parser.Parse()
-       if !ok {
+       if ok {
+               // reports errors to parser.Errorf
+               obj.Writeobjdirect(ctxt, output)
+       }
+       if !ok || diag {
                log.Printf("asm: assembly of %s failed", flag.Arg(0))
                os.Remove(*flags.OutputFile)
                os.Exit(1)
        }
-       obj.Writeobjdirect(ctxt, output)
        output.Flush()
 }

diff --git a/src/cmd/compile/internal/big/int.go b/src/cmd/compile/internal/big/int.go
index 16b7cd131bd753a0d47e48eb832058285b10b631..67ab7042ffe699b41d8da7b0081f670d163a6cf9 100644 (file)
--- a/src/cmd/compile/internal/big/int.go
+++ b/src/cmd/compile/internal/big/int.go
@@ -273,7 +273,7 @@ func (z *Int) Mod(x, y *Int) *Int {
 // DivMod implements Euclidean division and modulus (unlike Go):
 //
 //     q = x div y  such that
-//     m = x - y*q  with 0 <= m < |q|
+//     m = x - y*q  with 0 <= m < |y|
 //
 // (See Raymond T. Boute, ``The Euclidean definition of the functions
 // div and mod''. ACM Transactions on Programming Languages and

diff --git a/src/cmd/compile/internal/big/int_test.go b/src/cmd/compile/internal/big/int_test.go
index 5d65217c613507e3dae1d80e5cd14636b436e1fc..45a3765d3eee36d9669d7c5fda9211836b123ee0 100644 (file)
--- a/src/cmd/compile/internal/big/int_test.go
+++ b/src/cmd/compile/internal/big/int_test.go
@@ -544,6 +544,9 @@ var expTests = []struct {
        {"0x8000000000000000", "1000", "6719", "1603"},
        {"0x8000000000000000", "1000000", "6719", "3199"},
        {"0x8000000000000000", "-1000000", "6719", "1"},
+
+       {"0xffffffffffffffffffffffffffffffff", "0x12345678123456781234567812345678123456789", "0x01112222333344445555666677778889", "0x36168FA1DB3AAE6C8CE647E137F97A"},
+
        {
                "2938462938472983472983659726349017249287491026512746239764525612965293865296239471239874193284792387498274256129746192347",
                "298472983472983471903246121093472394872319615612417471234712061",
@@ -551,12 +554,24 @@ var expTests = []struct {
                "23537740700184054162508175125554701713153216681790245129157191391322321508055833908509185839069455749219131480588829346291",
        },
        // test case for issue 8822
+       {
+               "11001289118363089646017359372117963499250546375269047542777928006103246876688756735760905680604646624353196869572752623285140408755420374049317646428185270079555372763503115646054602867593662923894140940837479507194934267532831694565516466765025434902348314525627418515646588160955862839022051353653052947073136084780742729727874803457643848197499548297570026926927502505634297079527299004267769780768565695459945235586892627059178884998772989397505061206395455591503771677500931269477503508150175717121828518985901959919560700853226255420793148986854391552859459511723547532575574664944815966793196961286234040892865",
+               "0xB08FFB20760FFED58FADA86DFEF71AD72AA0FA763219618FE022C197E54708BB1191C66470250FCE8879487507CEE41381CA4D932F81C2B3F1AB20B539D50DCD",
+               "0xAC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC3192943DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310DCD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FBD5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF747359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E7303CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB694B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F9E4AFF73",
+               "21484252197776302499639938883777710321993113097987201050501182909581359357618579566746556372589385361683610524730509041328855066514963385522570894839035884713051640171474186548713546686476761306436434146475140156284389181808675016576845833340494848283681088886584219750554408060556769486628029028720727393293111678826356480455433909233520504112074401376133077150471237549474149190242010469539006449596611576612573955754349042329130631128234637924786466585703488460540228477440853493392086251021228087076124706778899179648655221663765993962724699135217212118535057766739392069738618682722216712319320435674779146070442",
+       },
        {
                "-0x1BCE04427D8032319A89E5C4136456671AC620883F2C4139E57F91307C485AD2D6204F4F87A58262652DB5DBBAC72B0613E51B835E7153BEC6068F5C8D696B74DBD18FEC316AEF73985CF0475663208EB46B4F17DD9DA55367B03323E5491A70997B90C059FB34809E6EE55BCFBD5F2F52233BFE62E6AA9E4E26A1D4C2439883D14F2633D55D8AA66A1ACD5595E778AC3A280517F1157989E70C1A437B849F1877B779CC3CDDEDE2DAA6594A6C66D181A00A5F777EE60596D8773998F6E988DEAE4CCA60E4DDCF9590543C89F74F603259FCAD71660D30294FBBE6490300F78A9D63FA660DC9417B8B9DDA28BEB3977B621B988E23D4D954F322C3540541BC649ABD504C50FADFD9F0987D58A2BF689313A285E773FF02899A6EF887D1D4A0D2",
                "0xB08FFB20760FFED58FADA86DFEF71AD72AA0FA763219618FE022C197E54708BB1191C66470250FCE8879487507CEE41381CA4D932F81C2B3F1AB20B539D50DCD",
                "0xAC6BDB41324A9A9BF166DE5E1389582FAF72B6651987EE07FC3192943DB56050A37329CBB4A099ED8193E0757767A13DD52312AB4B03310DCD7F48A9DA04FD50E8083969EDB767B0CF6095179A163AB3661A05FBD5FAAAE82918A9962F0B93B855F97993EC975EEAA80D740ADBF4FF747359D041D5C33EA71D281E446B14773BCA97B43A23FB801676BD207A436C6481F1D2B9078717461A5B9D32E688F87748544523B524B0D57D5EA77A2775D2ECFA032CFBDBF52FB3786160279004E57AE6AF874E7303CE53299CCC041C7BC308D82A5698F3A8D0C38271AE35F8E9DBFBB694B5C803D89F7AE435DE236D525F54759B65E372FCD68EF20FA7111F9E4AFF73",
                "21484252197776302499639938883777710321993113097987201050501182909581359357618579566746556372589385361683610524730509041328855066514963385522570894839035884713051640171474186548713546686476761306436434146475140156284389181808675016576845833340494848283681088886584219750554408060556769486628029028720727393293111678826356480455433909233520504112074401376133077150471237549474149190242010469539006449596611576612573955754349042329130631128234637924786466585703488460540228477440853493392086251021228087076124706778899179648655221663765993962724699135217212118535057766739392069738618682722216712319320435674779146070442",
        },
+
+       // test cases for issue 13907
+       {"0xffffffff00000001", "0xffffffff00000001", "0xffffffff00000001", "0"},
+       {"0xffffffffffffffff00000001", "0xffffffffffffffff00000001", "0xffffffffffffffff00000001", "0"},
+       {"0xffffffffffffffffffffffff00000001", "0xffffffffffffffffffffffff00000001", "0xffffffffffffffffffffffff00000001", "0"},
+       {"0xffffffffffffffffffffffffffffffff00000001", "0xffffffffffffffffffffffffffffffff00000001", "0xffffffffffffffffffffffffffffffff00000001", "0"},
 }
 
 func TestExp(t *testing.T) {
@@ -584,7 +599,7 @@ func TestExp(t *testing.T) {
                        t.Errorf("#%d: %v is not normalized", i, *z1)
                }
                if z1.Cmp(out) != 0 {
-                       t.Errorf("#%d: got %s want %s", i, z1, out)
+                       t.Errorf("#%d: got %x want %x", i, z1, out)
                }
 
                if m == nil {
@@ -593,7 +608,7 @@ func TestExp(t *testing.T) {
                        m = &Int{abs: nat{}} // m != nil && len(m.abs) == 0
                        z2 := new(Int).Exp(x, y, m)
                        if z2.Cmp(z1) != 0 {
-                               t.Errorf("#%d: got %s want %s", i, z2, z1)
+                               t.Errorf("#%d: got %x want %x", i, z2, z1)
                        }
                }
        }
@@ -1369,6 +1384,14 @@ func TestModSqrt(t *testing.T) {
                                t.Errorf("#%d: failed (sqrt(e) = %s)", i, &sqrt)
                        }
                }
+
+               if testing.Short() && i > 2 {
+                       break
+               }
+       }
+
+       if testing.Short() {
+               return
        }
 
        // exhaustive test for small values

diff --git a/src/cmd/compile/internal/big/nat.go b/src/cmd/compile/internal/big/nat.go
index e60318dc882e06ffea1e861814adc03ba7ba4eaa..79cf6e07f7fa1de3e8cdf25d2b1980bc168c7ba3 100644 (file)
--- a/src/cmd/compile/internal/big/nat.go
+++ b/src/cmd/compile/internal/big/nat.go
@@ -213,25 +213,25 @@ func (z nat) montgomery(x, y, m nat, k Word, n int) nat {
        if len(x) != n || len(y) != n || len(m) != n {
                panic("math/big: mismatched montgomery number lengths")
        }
-       var c1, c2, c3 Word
        z = z.make(n)
        z.clear()
+       var c Word
        for i := 0; i < n; i++ {
                d := y[i]
-               c2 = addMulVVW(z, x, d)
+               c2 := addMulVVW(z, x, d)
                t := z[0] * k
-               c3 = addMulVVW(z, m, t)
+               c3 := addMulVVW(z, m, t)
                copy(z, z[1:])
-               cx := c1 + c2
+               cx := c + c2
                cy := cx + c3
                z[n-1] = cy
                if cx < c2 || cy < c3 {
-                       c1 = 1
+                       c = 1
                } else {
-                       c1 = 0
+                       c = 0
                }
        }
-       if c1 != 0 {
+       if c != 0 {
                subVV(z, z, m)
        }
        return z
@@ -1056,23 +1056,19 @@ func (z nat) expNNWindowed(x, y, m nat) nat {
 // expNNMontgomery calculates x**y mod m using a fixed, 4-bit window.
 // Uses Montgomery representation.
 func (z nat) expNNMontgomery(x, y, m nat) nat {
-       var zz, one, rr, RR nat
-
        numWords := len(m)
 
        // We want the lengths of x and m to be equal.
+       // It is OK if x >= m as long as len(x) == len(m).
        if len(x) > numWords {
-               _, rr = rr.div(rr, x, m)
-       } else if len(x) < numWords {
-               rr = rr.make(numWords)
-               rr.clear()
-               for i := range x {
-                       rr[i] = x[i]
-               }
-       } else {
-               rr = x
+               _, x = nat(nil).div(nil, x, m)
+               // Note: now len(x) <= numWords, not guaranteed ==.
+       }
+       if len(x) < numWords {
+               rr := make(nat, numWords)
+               copy(rr, x)
+               x = rr
        }
-       x = rr
 
        // Ideally the precomputations would be performed outside, and reused
        // k0 = -m**-1 mod 2**_W. Algorithm from: Dumas, J.G. "On Newton–Raphson
@@ -1086,8 +1082,8 @@ func (z nat) expNNMontgomery(x, y, m nat) nat {
        k0 = -k0
 
        // RR = 2**(2*_W*len(m)) mod m
-       RR = RR.setWord(1)
-       zz = zz.shl(RR, uint(2*numWords*_W))
+       RR := nat(nil).setWord(1)
+       zz := nat(nil).shl(RR, uint(2*numWords*_W))
        _, RR = RR.div(RR, zz, m)
        if len(RR) < numWords {
                zz = zz.make(numWords)
@@ -1095,8 +1091,7 @@ func (z nat) expNNMontgomery(x, y, m nat) nat {
                RR = zz
        }
        // one = 1, with equal length to that of m
-       one = one.make(numWords)
-       one.clear()
+       one := make(nat, numWords)
        one[0] = 1
 
        const n = 4
@@ -1131,6 +1126,23 @@ func (z nat) expNNMontgomery(x, y, m nat) nat {
        }
        // convert to regular number
        zz = zz.montgomery(z, one, m, k0, numWords)
+
+       // One last reduction, just in case.
+       // See golang.org/issue/13907.
+       if zz.cmp(m) >= 0 {
+               // Common case is m has high bit set; in that case,
+               // since zz is the same length as m, there can be just
+               // one multiple of m to remove. Just subtract.
+               // We think that the subtract should be sufficient in general,
+               // so do that unconditionally, but double-check,
+               // in case our beliefs are wrong.
+               // The div is not expected to be reached.
+               zz = zz.sub(zz, m)
+               if zz.cmp(m) >= 0 {
+                       _, zz = nat(nil).div(nil, zz, m)
+               }
+       }
+
        return zz.norm()
 }
 

diff --git a/src/cmd/compile/internal/big/nat_test.go b/src/cmd/compile/internal/big/nat_test.go
index 56b62d24d64ac4bb6766fd742713c3ba280e9749..563ccb30523adab0c1f4982cc40bc1e67ea2944b 100644 (file)
--- a/src/cmd/compile/internal/big/nat_test.go
+++ b/src/cmd/compile/internal/big/nat_test.go
@@ -483,6 +483,12 @@ var expNNTests = []struct {
                "29834729834729834729347290846729561262544958723956495615629569234729836259263598127342374289365912465901365498236492183464",
                "23537740700184054162508175125554701713153216681790245129157191391322321508055833908509185839069455749219131480588829346291",
        },
+       {
+               "11521922904531591643048817447554701904414021819823889996244743037378330903763518501116638828335352811871131385129455853417360623007349090150042001944696604737499160174391019030572483602867266711107136838523916077674888297896995042968746762200926853379",
+               "426343618817810911523",
+               "444747819283133684179",
+               "42",
+       },
 }
 
 func TestExpNN(t *testing.T) {

diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go
index 7408680b5a175fe9ffbb49fa177fffa887f324ee..dbd8db16e5471272485be404703bcacd6450c9ad 100644 (file)
--- a/src/cmd/compile/internal/gc/fmt.go
+++ b/src/cmd/compile/internal/gc/fmt.go
@@ -420,7 +420,7 @@ func symfmt(s *Sym, flag int) string {
        if s.Pkg != nil && flag&obj.FmtShort == 0 {
                switch fmtmode {
                case FErr: // This is for the user
-                       if s.Pkg == localpkg {
+                       if s.Pkg == builtinpkg || s.Pkg == localpkg {
                                return s.Name
                        }
 

diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go
index ac55d4fd5d8242be7a048417739f947efe909509..60b93ef805045d8e8681d6377b9de05cacc45438 100644 (file)
--- a/src/cmd/compile/internal/gc/gen.go
+++ b/src/cmd/compile/internal/gc/gen.go
@@ -607,9 +607,6 @@ func Tempname(nn *Node, t *Type) {
        n.Esc = EscNever
        n.Name.Curfn = Curfn
        Curfn.Func.Dcl = list(Curfn.Func.Dcl, n)
-       if Debug['h'] != 0 {
-               println("H", n, n.Orig, funcSym(Curfn).Name)
-       }
 
        dowidth(t)
        n.Xoffset = 0

diff --git a/src/cmd/compile/internal/gc/lex.go b/src/cmd/compile/internal/gc/lex.go
index 9a1e70f43de1c9d6ed146be3f08d973645db5801..e4ce9c796be082b259ce3edce1480da77ecc2818 100644 (file)
--- a/src/cmd/compile/internal/gc/lex.go
+++ b/src/cmd/compile/internal/gc/lex.go
@@ -107,7 +107,7 @@ func Main() {
 
        Thearch.Linkarchinit()
        Ctxt = obj.Linknew(Thearch.Thelinkarch)
-       Ctxt.Diag = Yyerror
+       Ctxt.DiagFunc = Yyerror
        Ctxt.Bso = &bstdout
        bstdout = *obj.Binitw(os.Stdout)
 
@@ -845,6 +845,13 @@ func importfile(f *Val, line int) {
                }
                p := fmt.Sprintf("package %s %s\n$$\n", importpkg.Name, tag)
                cannedimports(file, p)
+               // Reset incannedimport flag (we are not truly in a
+               // canned import) - this will cause importpkg.Direct to
+               // be set via parser.import_package (was issue #13977).
+               //
+               // TODO(gri) Remove this global variable and convoluted
+               // code in the process of streamlining the import code.
+               incannedimport = 0
 
        default:
                Yyerror("no import in %q", f.U.(string))
@@ -927,13 +934,9 @@ func isfrog(c int) bool {
 }
 
 type yySymType struct {
-       yys  int
-       node *Node
-       list *NodeList
-       typ  *Type
-       sym  *Sym
-       val  Val
-       op   Op
+       sym *Sym
+       val Val
+       op  Op
 }
 
 const (

diff --git a/src/cmd/compile/internal/gc/opnames.go b/src/cmd/compile/internal/gc/opnames.go
index d5183234b924cae7dffcb2570b64977231e57ca4..df0d8cb7fbd18081b45afeb97eef9bbde641ccfe 100644 (file)
--- a/src/cmd/compile/internal/gc/opnames.go
+++ b/src/cmd/compile/internal/gc/opnames.go
@@ -149,6 +149,7 @@ var opnames = []string{
        OCFUNC:           "CFUNC",
        OCHECKNIL:        "CHECKNIL",
        OVARKILL:         "VARKILL",
+       OVARLIVE:         "VARLIVE",
        OREGISTER:        "REGISTER",
        OINDREG:          "INDREG",
        OCMP:             "CMP",

diff --git a/src/cmd/compile/internal/gc/parser.go b/src/cmd/compile/internal/gc/parser.go
index 3279f4c6b074713d821efad025dce10a2f9e974e..054cf7365617ce662a5b9b244c1c751900f95a0d 100644 (file)
--- a/src/cmd/compile/internal/gc/parser.go
+++ b/src/cmd/compile/internal/gc/parser.go
@@ -668,9 +668,14 @@ func (p *parser) simple_stmt(labelOk, rangeOk bool) *Node {
                        if labelOk {
                                // If we have a labelname, it was parsed by operand
                                // (calling p.name()) and given an ONAME, ONONAME, OTYPE, OPACK, or OLITERAL node.
+                               // We only have a labelname if there is a symbol (was issue 14006).
                                switch lhs.Op {
                                case ONAME, ONONAME, OTYPE, OPACK, OLITERAL:
-                                       lhs = newname(lhs.Sym)
+                                       if lhs.Sym != nil {
+                                               lhs = newname(lhs.Sym)
+                                               break
+                                       }
+                                       fallthrough
                                default:
                                        p.syntax_error("expecting semicolon or newline or }")
                                        // we already progressed, no need to advance
@@ -2496,6 +2501,24 @@ func (p *parser) interfacedcl() *Node {
                ifacedcl(meth)
                return meth
 
+       case '@', '?':
+               // newname indcl
+               // We arrive here when parsing an interface type declared inside
+               // an exported and inlineable function and the interface declares
+               // unexported methods (which are then package-qualified).
+               //
+               // Since the compiler always flattens embedded interfaces, we
+               // will never see an embedded package-qualified interface in export
+               // data; i.e., when we reach here we know it must be a method.
+               //
+               // See also issue 14164.
+               mname := newname(p.sym())
+               sig := p.indcl()
+
+               meth := Nod(ODCLFIELD, mname, sig)
+               ifacedcl(meth)
+               return meth
+
        case '(':
                p.next()
                pname := p.packname(nil)

diff --git a/src/cmd/compile/internal/gc/ssa.go b/src/cmd/compile/internal/gc/ssa.go
index 35a492923fa326472e2d8c8093d52165d6ceb7f9..3f8fdce83bb7616be9aabae35f980a711f13a1a7 100644 (file)
--- a/src/cmd/compile/internal/gc/ssa.go
+++ b/src/cmd/compile/internal/gc/ssa.go
@@ -544,7 +544,8 @@ func (s *state) stmt(n *Node) {
        // Expression statements
        case OCALLFUNC, OCALLMETH, OCALLINTER:
                s.call(n, callNormal)
-               if n.Op == OCALLFUNC && n.Left.Op == ONAME && n.Left.Class == PFUNC && n.Left.Sym.Pkg == Runtimepkg && n.Left.Sym.Name == "gopanic" {
+               if n.Op == OCALLFUNC && n.Left.Op == ONAME && n.Left.Class == PFUNC && n.Left.Sym.Pkg == Runtimepkg &&
+                       (n.Left.Sym.Name == "gopanic" || n.Left.Sym.Name == "selectgo") {
                        m := s.mem()
                        b := s.endBlock()
                        b.Kind = ssa.BlockExit
@@ -873,6 +874,10 @@ func (s *state) stmt(n *Node) {
                        lab.breakTarget = nil
                }
 
+               // OSWITCH never falls through (s.curBlock == nil here).
+               // OSELECT does not fall through if we're calling selectgo.
+               // OSELECT does fall through if we're calling selectnb{send,recv}[2].
+               // In those latter cases, go to the code after the select.
                if b := s.endBlock(); b != nil {
                        b.AddEdgeTo(bEnd)
                }

diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index 4cd696a0a17de35b131f5dd322f8ac298cae18e6..156b86810947b8e02bfb381f28742a5de389faff 100644 (file)
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -336,7 +336,11 @@ func (t *tester) registerTests() {
        } else {
                // Use a format string to only list packages and commands that have tests.
                const format = "{{if (or .TestGoFiles .XTestGoFiles)}}{{.ImportPath}}{{end}}"
-               cmd := exec.Command("go", "list", "-f", format, "std")
+               cmd := exec.Command("go", "list", "-f", format)
+               if t.race {
+                       cmd.Args = append(cmd.Args, "-tags", "race")
+               }
+               cmd.Args = append(cmd.Args, "std")
                if !t.race {
                        cmd.Args = append(cmd.Args, "cmd")
                }

diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go
index ea2eb77470e1a4ccaaed7c52933b4dc426961c3f..c81bd40864a3c74bc36a8f40f00893bc9dd9b74b 100644 (file)
--- a/src/cmd/go/alldocs.go
+++ b/src/cmd/go/alldocs.go
@@ -93,7 +93,8 @@ and test commands:
                Supported only on linux/amd64, freebsd/amd64, darwin/amd64 and windows/amd64.
        -msan
                enable interoperation with memory sanitizer.
-               Supported only on linux/amd64.
+               Supported only on linux/amd64,
+               and only with Clang/LLVM as the host C compiler.
        -v
                print the names of packages as they are compiled.
        -work
@@ -603,6 +604,14 @@ syntax of package template.  The default output is equivalent to -f
         XTestImports []string // imports from XTestGoFiles
     }
 
+The error information, if any, is
+
+    type PackageError struct {
+        ImportStack   []string // shortest path from package named on command line to this one
+        Pos           string   // position of error (if present, file:line:col)
+        Err           string   // the error itself
+    }
+
 The template function "join" calls strings.Join.
 
 The template function "context" returns the build context, defined as:

diff --git a/src/cmd/go/build.go b/src/cmd/go/build.go
index 6a8edaf6d25f065559261a555c681a2a5954019b..a1f925ed0ba2d7b8c26410150a78bd299c56edb8 100644 (file)
--- a/src/cmd/go/build.go
+++ b/src/cmd/go/build.go
@@ -72,7 +72,8 @@ and test commands:
                Supported only on linux/amd64, freebsd/amd64, darwin/amd64 and windows/amd64.
        -msan
                enable interoperation with memory sanitizer.
-               Supported only on linux/amd64.
+               Supported only on linux/amd64,
+               and only with Clang/LLVM as the host C compiler.
        -v
                print the names of packages as they are compiled.
        -work
@@ -1835,6 +1836,7 @@ var objectMagic = [][]byte{
        {0x4d, 0x5a, 0x90, 0x00, 0x03, 0x00},      // PE (Windows) as generated by 6l/8l and gcc
        {0x00, 0x00, 0x01, 0xEB},                  // Plan 9 i386
        {0x00, 0x00, 0x8a, 0x97},                  // Plan 9 amd64
+       {0x00, 0x00, 0x06, 0x47},                  // Plan 9 arm
 }
 
 func isObject(s string) bool {
@@ -2568,11 +2570,11 @@ func (tools gccgoToolchain) asm(b *builder, p *Package, obj, ofile, sfile string
        sfile = mkAbs(p.Dir, sfile)
        defs := []string{"-D", "GOOS_" + goos, "-D", "GOARCH_" + goarch}
        if pkgpath := gccgoCleanPkgpath(p); pkgpath != "" {
-               defs = append(defs, `-D`, `GOPKGPATH="`+pkgpath+`"`)
+               defs = append(defs, `-D`, `GOPKGPATH=`+pkgpath)
        }
        defs = tools.maybePIC(defs)
        defs = append(defs, b.gccArchArgs()...)
-       return b.run(p.Dir, p.ImportPath, nil, tools.compiler(), "-I", obj, "-o", ofile, defs, sfile)
+       return b.run(p.Dir, p.ImportPath, nil, tools.compiler(), "-xassembler-with-cpp", "-I", obj, "-c", "-o", ofile, defs, sfile)
 }
 
 func (gccgoToolchain) pkgpath(basedir string, p *Package) string {

diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go
index 50c7521831e0703d34c17cc6aed1afbbd2c86817..6d12f7507396540fb0f4ad77cf4c382f04645c69 100644 (file)
--- a/src/cmd/go/go_test.go
+++ b/src/cmd/go/go_test.go
@@ -657,6 +657,9 @@ func TestGoBuildDashAInDevBranch(t *testing.T) {
        tg.setenv("TESTGO_IS_GO_RELEASE", "0")
        tg.run("build", "-v", "-a", "math")
        tg.grepStderr("runtime", "testgo build -a math in dev branch DID NOT build runtime, but should have")
+
+       // Everything is out of date. Rebuild to leave things in a better state.
+       tg.run("install", "std")
 }
 
 func TestGoBuildDashAInReleaseBranch(t *testing.T) {
@@ -666,10 +669,110 @@ func TestGoBuildDashAInReleaseBranch(t *testing.T) {
 
        tg := testgo(t)
        defer tg.cleanup()
-       tg.run("install", "math") // should be up to date already but just in case
+       tg.run("install", "math", "net/http") // should be up to date already but just in case
        tg.setenv("TESTGO_IS_GO_RELEASE", "1")
-       tg.run("build", "-v", "-a", "math")
-       tg.grepStderr("runtime", "testgo build -a math in dev branch did not build runtime, but should have")
+       tg.run("install", "-v", "-a", "math")
+       tg.grepStderr("runtime", "testgo build -a math in release branch DID NOT build runtime, but should have")
+
+       // Now runtime.a is updated (newer mtime), so everything would look stale if not for being a release.
+       tg.run("build", "-v", "net/http")
+       tg.grepStderrNot("strconv", "testgo build -v net/http in release branch with newer runtime.a DID build strconv but should not have")
+       tg.grepStderrNot("golang.org/x/net/http2/hpack", "testgo build -v net/http in release branch with newer runtime.a DID build .../golang.org/x/net/http2/hpack but should not have")
+       tg.grepStderrNot("net/http", "testgo build -v net/http in release branch with newer runtime.a DID build net/http but should not have")
+
+       // Everything is out of date. Rebuild to leave things in a better state.
+       tg.run("install", "std")
+}
+
+func TestNewReleaseRebuildsStalePackagesInGOPATH(t *testing.T) {
+       if testing.Short() {
+               t.Skip("don't rebuild the standard library in short mode")
+       }
+
+       tg := testgo(t)
+       defer tg.cleanup()
+
+       addNL := func(name string) (restore func()) {
+               data, err := ioutil.ReadFile(name)
+               if err != nil {
+                       t.Fatal(err)
+               }
+               old := data
+               data = append(data, '\n')
+               if err := ioutil.WriteFile(name, append(data, '\n'), 0666); err != nil {
+                       t.Fatal(err)
+               }
+               tg.sleep()
+               return func() {
+                       if err := ioutil.WriteFile(name, old, 0666); err != nil {
+                               t.Fatal(err)
+                       }
+               }
+       }
+
+       tg.setenv("TESTGO_IS_GO_RELEASE", "1")
+
+       tg.tempFile("d1/src/p1/p1.go", `package p1`)
+       tg.setenv("GOPATH", tg.path("d1"))
+       tg.run("install", "-a", "p1")
+       tg.wantNotStale("p1", "./testgo list claims p1 is stale, incorrectly")
+       tg.sleep()
+
+       // Changing mtime and content of runtime/internal/sys/sys.go
+       // should have no effect: we're in a release, which doesn't rebuild
+       // for general mtime or content changes.
+       sys := runtime.GOROOT() + "/src/runtime/internal/sys/sys.go"
+       restore := addNL(sys)
+       defer restore()
+       tg.wantNotStale("p1", "./testgo list claims p1 is stale, incorrectly, after updating runtime/internal/sys/sys.go")
+       restore()
+       tg.wantNotStale("p1", "./testgo list claims p1 is stale, incorrectly, after restoring runtime/internal/sys/sys.go")
+
+       // But changing runtime/internal/sys/zversion.go should have an effect:
+       // that's how we tell when we flip from one release to another.
+       zversion := runtime.GOROOT() + "/src/runtime/internal/sys/zversion.go"
+       restore = addNL(zversion)
+       defer restore()
+       tg.wantStale("p1", "./testgo list claims p1 is NOT stale, incorrectly, after changing to new release")
+       restore()
+       tg.wantNotStale("p1", "./testgo list claims p1 is stale, incorrectly, after changing back to old release")
+       addNL(zversion)
+       tg.wantStale("p1", "./testgo list claims p1 is NOT stale, incorrectly, after changing again to new release")
+       tg.run("install", "p1")
+       tg.wantNotStale("p1", "./testgo list claims p1 is stale after building with new release")
+
+       // Restore to "old" release.
+       restore()
+       tg.wantStale("p1", "./testgo list claims p1 is NOT stale, incorrectly, after changing to old release after new build")
+       tg.run("install", "p1")
+       tg.wantNotStale("p1", "./testgo list claims p1 is stale after building with old release")
+
+       // Everything is out of date. Rebuild to leave things in a better state.
+       tg.run("install", "std")
+}
+
+func TestGoListStandard(t *testing.T) {
+       tg := testgo(t)
+       defer tg.cleanup()
+       tg.cd(runtime.GOROOT() + "/src")
+       tg.run("list", "-f", "{{if not .Standard}}{{.ImportPath}}{{end}}", "./...")
+       stdout := tg.getStdout()
+       for _, line := range strings.Split(stdout, "\n") {
+               if strings.HasPrefix(line, "_/") && strings.HasSuffix(line, "/src") {
+                       // $GOROOT/src shows up if there are any .go files there.
+                       // We don't care.
+                       continue
+               }
+               if line == "" {
+                       continue
+               }
+               t.Errorf("package in GOROOT not listed as standard: %v", line)
+       }
+
+       // Similarly, expanding std should include some of our vendored code.
+       tg.run("list", "std", "cmd")
+       tg.grepStdout("golang.org/x/net/http2/hpack", "list std cmd did not mention vendored hpack")
+       tg.grepStdout("golang.org/x/arch/x86/x86asm", "list std cmd did not mention vendored x86asm")
 }
 
 func TestGoInstallCleansUpAfterGoBuild(t *testing.T) {
@@ -725,8 +828,8 @@ func TestGoInstallRebuildsStalePackagesInOtherGOPATH(t *testing.T) {
        sep := string(filepath.ListSeparator)
        tg.setenv("GOPATH", tg.path("d1")+sep+tg.path("d2"))
        tg.run("install", "p1")
-       tg.wantNotStale("p1", "./testgo list mypkg claims p1 is stale, incorrectly")
-       tg.wantNotStale("p2", "./testgo list mypkg claims p2 is stale, incorrectly")
+       tg.wantNotStale("p1", "./testgo list claims p1 is stale, incorrectly")
+       tg.wantNotStale("p2", "./testgo list claims p2 is stale, incorrectly")
        tg.sleep()
        if f, err := os.OpenFile(tg.path("d2/src/p2/p2.go"), os.O_WRONLY|os.O_APPEND, 0); err != nil {
                t.Fatal(err)
@@ -735,12 +838,12 @@ func TestGoInstallRebuildsStalePackagesInOtherGOPATH(t *testing.T) {
        } else {
                tg.must(f.Close())
        }
-       tg.wantStale("p2", "./testgo list mypkg claims p2 is NOT stale, incorrectly")
-       tg.wantStale("p1", "./testgo list mypkg claims p1 is NOT stale, incorrectly")
+       tg.wantStale("p2", "./testgo list claims p2 is NOT stale, incorrectly")
+       tg.wantStale("p1", "./testgo list claims p1 is NOT stale, incorrectly")
 
        tg.run("install", "p1")
-       tg.wantNotStale("p2", "./testgo list mypkg claims p2 is stale after reinstall, incorrectly")
-       tg.wantNotStale("p1", "./testgo list mypkg claims p1 is stale after reinstall, incorrectly")
+       tg.wantNotStale("p2", "./testgo list claims p2 is stale after reinstall, incorrectly")
+       tg.wantNotStale("p1", "./testgo list claims p1 is stale after reinstall, incorrectly")
 }
 
 func TestGoInstallDetectsRemovedFiles(t *testing.T) {
@@ -1590,7 +1693,7 @@ func TestGoTestDashOWritesBinary(t *testing.T) {
 }
 
 // Issue 4568.
-func TestSymlinksDoNotConfuseGoList(t *testing.T) {
+func TestSymlinksList(t *testing.T) {
        switch runtime.GOOS {
        case "plan9", "windows":
                t.Skipf("skipping symlink test on %s", runtime.GOOS)
@@ -1609,6 +1712,58 @@ func TestSymlinksDoNotConfuseGoList(t *testing.T) {
        }
 }
 
+// Issue 14054.
+func TestSymlinksVendor(t *testing.T) {
+       switch runtime.GOOS {
+       case "plan9", "windows":
+               t.Skipf("skipping symlink test on %s", runtime.GOOS)
+       }
+
+       tg := testgo(t)
+       defer tg.cleanup()
+       tg.setenv("GO15VENDOREXPERIMENT", "1")
+       tg.tempDir("gopath/src/dir1/vendor/v")
+       tg.tempFile("gopath/src/dir1/p.go", "package main\nimport _ `v`\nfunc main(){}")
+       tg.tempFile("gopath/src/dir1/vendor/v/v.go", "package v")
+       tg.must(os.Symlink(tg.path("gopath/src/dir1"), tg.path("symdir1")))
+       tg.setenv("GOPATH", tg.path("gopath"))
+       tg.cd(tg.path("symdir1"))
+       tg.run("list", "-f", "{{.Root}}", ".")
+       if strings.TrimSpace(tg.getStdout()) != tg.path("gopath") {
+               t.Error("list confused by symlinks")
+       }
+
+       // All of these should succeed, not die in vendor-handling code.
+       tg.run("run", "p.go")
+       tg.run("build")
+       tg.run("install")
+}
+
+func TestSymlinksInternal(t *testing.T) {
+       switch runtime.GOOS {
+       case "plan9", "windows":
+               t.Skipf("skipping symlink test on %s", runtime.GOOS)
+       }
+
+       tg := testgo(t)
+       defer tg.cleanup()
+       tg.tempDir("gopath/src/dir1/internal/v")
+       tg.tempFile("gopath/src/dir1/p.go", "package main\nimport _ `dir1/internal/v`\nfunc main(){}")
+       tg.tempFile("gopath/src/dir1/internal/v/v.go", "package v")
+       tg.must(os.Symlink(tg.path("gopath/src/dir1"), tg.path("symdir1")))
+       tg.setenv("GOPATH", tg.path("gopath"))
+       tg.cd(tg.path("symdir1"))
+       tg.run("list", "-f", "{{.Root}}", ".")
+       if strings.TrimSpace(tg.getStdout()) != tg.path("gopath") {
+               t.Error("list confused by symlinks")
+       }
+
+       // All of these should succeed, not die in internal-handling code.
+       tg.run("run", "p.go")
+       tg.run("build")
+       tg.run("install")
+}
+
 // Issue 4515.
 func TestInstallWithTags(t *testing.T) {
        tg := testgo(t)
@@ -2255,6 +2410,7 @@ func TestGoGetInsecureCustomDomain(t *testing.T) {
 }
 
 func TestIssue10193(t *testing.T) {
+       t.Skip("depends on code.google.com")
        testenv.MustHaveExternalNetwork(t)
        if _, err := exec.LookPath("hg"); err != nil {
                t.Skip("skipping because hg binary not found")

diff --git a/src/cmd/go/list.go b/src/cmd/go/list.go
index 35c7cc4f2a73a8168570695625c88f6a2b56700e..8f741a636b1700219a972fca935a9c97e233ffa9 100644 (file)
--- a/src/cmd/go/list.go
+++ b/src/cmd/go/list.go
@@ -78,6 +78,14 @@ syntax of package template.  The default output is equivalent to -f
         XTestImports []string // imports from XTestGoFiles
     }
 
+The error information, if any, is
+
+    type PackageError struct {
+        ImportStack   []string // shortest path from package named on command line to this one
+        Pos           string   // position of error (if present, file:line:col)
+        Err           string   // the error itself
+    }
+
 The template function "join" calls strings.Join.
 
 The template function "context" returns the build context, defined as:

diff --git a/src/cmd/go/main.go b/src/cmd/go/main.go
index c6d77f7884f20febdd0ae69512e73787a7b5d080..d384594722511028a25ea87d21279a35c72e7468 100644 (file)
--- a/src/cmd/go/main.go
+++ b/src/cmd/go/main.go
@@ -524,6 +524,15 @@ func hasFilePathPrefix(s, prefix string) bool {
        }
 }
 
+// expandPath returns the symlink-expanded form of path.
+func expandPath(p string) string {
+       x, err := filepath.EvalSymlinks(p)
+       if err == nil {
+               return x
+       }
+       return p
+}
+
 // treeCanMatchPattern(pattern)(name) reports whether
 // name or children of name can possibly match pattern.
 // Pattern is the same limited glob accepted by matchPattern.
@@ -588,10 +597,9 @@ func matchPackages(pattern string) []string {
                        }
 
                        name := filepath.ToSlash(path[len(src):])
-                       if pattern == "std" && (strings.Contains(name, ".") || name == "cmd") {
+                       if pattern == "std" && (!isStandardImportPath(name) || name == "cmd") {
                                // The name "std" is only the standard library.
-                               // If the name has a dot, assume it's a domain name for go get,
-                               // and if the name is cmd, it's the root of the command tree.
+                               // If the name is cmd, it's the root of the command tree.
                                return filepath.SkipDir
                        }
                        if !treeCanMatch(name) {

diff --git a/src/cmd/go/pkg.go b/src/cmd/go/pkg.go
index 0507841c6b13b58503c99b36753fe2a2037e388f..a804ccd277cfdff699efff776e337543f5f8678c 100644 (file)
--- a/src/cmd/go/pkg.go
+++ b/src/cmd/go/pkg.go
@@ -153,7 +153,7 @@ func (p *Package) copyBuild(pp *build.Package) {
        p.ConflictDir = pp.ConflictDir
        // TODO? Target
        p.Goroot = pp.Goroot
-       p.Standard = p.Goroot && p.ImportPath != "" && !strings.Contains(p.ImportPath, ".")
+       p.Standard = p.Goroot && p.ImportPath != "" && isStandardImportPath(p.ImportPath)
        p.GoFiles = pp.GoFiles
        p.CgoFiles = pp.CgoFiles
        p.IgnoredGoFiles = pp.IgnoredGoFiles
@@ -177,6 +177,19 @@ func (p *Package) copyBuild(pp *build.Package) {
        p.XTestImports = pp.XTestImports
 }
 
+// isStandardImportPath reports whether $GOROOT/src/path should be considered
+// part of the standard distribution. For historical reasons we allow people to add
+// their own code to $GOROOT instead of using $GOPATH, but we assume that
+// code will start with a domain name (dot in the first element).
+func isStandardImportPath(path string) bool {
+       i := strings.Index(path, "/")
+       if i < 0 {
+               i = len(path)
+       }
+       elem := path[:i]
+       return !strings.Contains(elem, ".")
+}
+
 // A PackageError describes an error loading information about a package.
 type PackageError struct {
        ImportStack   []string // shortest path from package named on command line to this one
@@ -362,7 +375,7 @@ func loadImport(path, srcDir string, parent *Package, stk *importStack, importPo
                err = fmt.Errorf("code in directory %s expects import %q", bp.Dir, bp.ImportComment)
        }
        p.load(stk, bp, err)
-       if p.Error != nil && len(importPos) > 0 {
+       if p.Error != nil && p.Error.Pos == "" && len(importPos) > 0 {
                pos := importPos[0]
                pos.Filename = shortPath(pos.Filename)
                p.Error.Pos = pos.String()
@@ -402,11 +415,18 @@ func vendoredImportPath(parent *Package, path string) (found string) {
        if parent == nil || parent.Root == "" || !go15VendorExperiment {
                return path
        }
+
        dir := filepath.Clean(parent.Dir)
        root := filepath.Join(parent.Root, "src")
+       if !hasFilePathPrefix(dir, root) {
+               // Look for symlinks before reporting error.
+               dir = expandPath(dir)
+               root = expandPath(root)
+       }
        if !hasFilePathPrefix(dir, root) || len(dir) <= len(root) || dir[len(root)] != filepath.Separator {
                fatalf("invalid vendoredImportPath: dir=%q root=%q separator=%q", dir, root, string(filepath.Separator))
        }
+
        vpath := "vendor/" + path
        for i := len(dir); i >= len(root); i-- {
                if i < len(dir) && dir[i] != filepath.Separator {
@@ -520,6 +540,13 @@ func disallowInternal(srcDir string, p *Package, stk *importStack) *Package {
                return p
        }
 
+       // Look for symlinks before reporting error.
+       srcDir = expandPath(srcDir)
+       parent = expandPath(parent)
+       if hasFilePathPrefix(filepath.Clean(srcDir), filepath.Clean(parent)) {
+               return p
+       }
+
        // Internal is present, and srcDir is outside parent's tree. Not allowed.
        perr := *p
        perr.Error = &PackageError{
@@ -617,6 +644,13 @@ func disallowVendorVisibility(srcDir string, p *Package, stk *importStack) *Pack
                return p
        }
 
+       // Look for symlinks before reporting error.
+       srcDir = expandPath(srcDir)
+       parent = expandPath(parent)
+       if hasFilePathPrefix(filepath.Clean(srcDir), filepath.Clean(parent)) {
+               return p
+       }
+
        // Vendor is present, and srcDir is outside parent's tree. Not allowed.
        perr := *p
        perr.Error = &PackageError{
@@ -933,6 +967,17 @@ func (p *Package) load(stk *importStack, bp *build.Package, err error) *Package
                                }
                        }
                }
+               if p.Standard && !p1.Standard && p.Error == nil {
+                       p.Error = &PackageError{
+                               ImportStack: stk.copy(),
+                               Err:         fmt.Sprintf("non-standard import %q in standard package %q", path, p.ImportPath),
+                       }
+                       pos := p.build.ImportPos[path]
+                       if len(pos) > 0 {
+                               p.Error.Pos = pos[0].String()
+                       }
+               }
+
                path = p1.ImportPath
                importPaths[i] = path
                if i < len(p.Imports) {
@@ -1497,11 +1542,14 @@ func computeBuildID(p *Package) {
                fmt.Fprintf(h, "file %s\n", file)
        }
 
-       // Include the content of runtime/zversion.go in the hash
+       // Include the content of runtime/internal/sys/zversion.go in the hash
        // for package runtime. This will give package runtime a
        // different build ID in each Go release.
-       if p.Standard && p.ImportPath == "runtime" {
-               data, _ := ioutil.ReadFile(filepath.Join(p.Dir, "zversion.go"))
+       if p.Standard && p.ImportPath == "runtime/internal/sys" {
+               data, err := ioutil.ReadFile(filepath.Join(p.Dir, "zversion.go"))
+               if err != nil {
+                       fatalf("go: %s", err)
+               }
                fmt.Fprintf(h, "zversion %q\n", string(data))
        }
 

diff --git a/src/cmd/go/run.go b/src/cmd/go/run.go
index 7ee067a003ded229eaae3d3201131280fd4ecfbe..bf10f4f3e91307a4005b738adacbf7066998a0db 100644 (file)
--- a/src/cmd/go/run.go
+++ b/src/cmd/go/run.go
@@ -89,8 +89,18 @@ func runRun(cmd *Command, args []string) {
                fatalf("%s", p.Error)
        }
        p.omitDWARF = true
-       for _, err := range p.DepsErrors {
-               errorf("%s", err)
+       if len(p.DepsErrors) > 0 {
+               // Since these are errors in dependencies,
+               // the same error might show up multiple times,
+               // once in each package that depends on it.
+               // Only print each once.
+               printed := map[*PackageError]bool{}
+               for _, err := range p.DepsErrors {
+                       if !printed[err] {
+                               printed[err] = true
+                               errorf("%s", err)
+                       }
+               }
        }
        exitIfErrors()
        if p.Name != "main" {

diff --git a/src/cmd/go/testdata/src/vend/hello/hello_test.go b/src/cmd/go/testdata/src/vend/hello/hello_test.go
index 5e72ada9387a7a79d903d8557b214c0899c432d5..7190f599d68ca8b543ca7c55e1a870973cea1972 100644 (file)
--- a/src/cmd/go/testdata/src/vend/hello/hello_test.go
+++ b/src/cmd/go/testdata/src/vend/hello/hello_test.go
@@ -7,6 +7,6 @@ import (
 
 func TestMsgInternal(t *testing.T) {
        if strings.Msg != "hello, world" {
-               t.Fatal("unexpected msg: %v", strings.Msg)
+               t.Fatalf("unexpected msg: %v", strings.Msg)
        }
 }

diff --git a/src/cmd/go/testdata/src/vend/hello/hellox_test.go b/src/cmd/go/testdata/src/vend/hello/hellox_test.go
index 96e6049dad0ae1642f9fbdcb3a91917675ecd52d..3f2165bd38abea1c76ebf20edcfce8478c3b9ce6 100644 (file)
--- a/src/cmd/go/testdata/src/vend/hello/hellox_test.go
+++ b/src/cmd/go/testdata/src/vend/hello/hellox_test.go
@@ -7,6 +7,6 @@ import (
 
 func TestMsgExternal(t *testing.T) {
        if strings.Msg != "hello, world" {
-               t.Fatal("unexpected msg: %v", strings.Msg)
+               t.Fatalf("unexpected msg: %v", strings.Msg)
        }
 }

diff --git a/src/cmd/go/vcs.go b/src/cmd/go/vcs.go
index 074dd8b2b1259bb7bb7105af9b474b5009bd76c0..342edee50d9c8688dc52cd37d1e30c95af8b3b19 100644 (file)
--- a/src/cmd/go/vcs.go
+++ b/src/cmd/go/vcs.go
@@ -122,7 +122,7 @@ var vcsGit = &vcsCmd{
        name: "Git",
        cmd:  "git",
 
-       createCmd:   []string{"clone {repo} {dir}", "-C {dir} submodule update --init --recursive"},
+       createCmd:   []string{"clone {repo} {dir}", "-go-internal-cd {dir} submodule update --init --recursive"},
        downloadCmd: []string{"pull --ff-only", "submodule update --init --recursive"},
 
        tagCmd: []tagCmd{
@@ -335,6 +335,15 @@ func (v *vcsCmd) run1(dir string, cmdline string, keyval []string, verbose bool)
                args[i] = expand(m, arg)
        }
 
+       if len(args) >= 2 && args[0] == "-go-internal-cd" {
+               if filepath.IsAbs(args[1]) {
+                       dir = args[1]
+               } else {
+                       dir = filepath.Join(dir, args[1])
+               }
+               args = args[2:]
+       }
+
        _, err := exec.LookPath(v.cmd)
        if err != nil {
                fmt.Fprintf(os.Stderr,

diff --git a/src/cmd/go/vcs_test.go b/src/cmd/go/vcs_test.go
index f5d5e4f4f0b521a5ccbe99b5039a0ee95965fd7b..a90c2061edb2505fea67e84d98373b5748a29c55 100644 (file)
--- a/src/cmd/go/vcs_test.go
+++ b/src/cmd/go/vcs_test.go
@@ -18,14 +18,14 @@ func TestRepoRootForImportPath(t *testing.T) {
                path string
                want *repoRoot
        }{
-               {
+               /*{
                        "code.google.com/p/go",
                        &repoRoot{
                                vcs:  vcsHg,
                                repo: "https://code.google.com/p/go",
                        },
                },
-               /*{
+               {
                        "code.google.com/r/go",
                        &repoRoot{
                                vcs:  vcsHg,

diff --git a/src/cmd/internal/obj/arm/anames5.go b/src/cmd/internal/obj/arm/anames5.go
index e3f98ce83199413c4127017325f05fe1b55ae91c..7fdd9623bd0dd029361bc70c689eaf90b3679f15 100644 (file)
--- a/src/cmd/internal/obj/arm/anames5.go
+++ b/src/cmd/internal/obj/arm/anames5.go
@@ -9,6 +9,7 @@ var cnames5 = []string{
        "REG",
        "REGREG",
        "REGREG2",
+       "REGLIST",
        "SHIFT",
        "FREG",
        "PSR",

diff --git a/src/cmd/internal/obj/arm/asm5.go b/src/cmd/internal/obj/arm/asm5.go
index 3ba0c7d95bc4f4896a35800e5250fa6d530b8cc3..d75a16354cba9ac66913bbbd2f8544ff25050d50 100644 (file)
--- a/src/cmd/internal/obj/arm/asm5.go
+++ b/src/cmd/internal/obj/arm/asm5.go
@@ -1561,7 +1561,7 @@ func asmout(ctxt *obj.Link, p *obj.Prog, o *Optab, out []uint32) {
                o1 |= (uint32(p.To.Reg) & 15) << 12
 
        case 5: /* bra s */
-               o1 = opbra(ctxt, int(p.As), int(p.Scond))
+               o1 = opbra(ctxt, p, int(p.As), int(p.Scond))
 
                v := int32(-8)
                if p.To.Sym != nil {
@@ -2594,9 +2594,9 @@ func oprrr(ctxt *obj.Link, a int, sc int) uint32 {
        return 0
 }
 
-func opbra(ctxt *obj.Link, a int, sc int) uint32 {
+func opbra(ctxt *obj.Link, p *obj.Prog, a int, sc int) uint32 {
        if sc&(C_SBIT|C_PBIT|C_WBIT) != 0 {
-               ctxt.Diag(".nil/.nil/.W on bra instruction")
+               ctxt.Diag("%v: .nil/.nil/.W on bra instruction", p)
        }
        sc &= C_SCOND
        sc ^= C_SCOND_XOR
@@ -2604,7 +2604,7 @@ func opbra(ctxt *obj.Link, a int, sc int) uint32 {
                return uint32(sc)<<28 | 0x5<<25 | 0x1<<24
        }
        if sc != 0xe {
-               ctxt.Diag(".COND on bcond instruction")
+               ctxt.Diag("%v: .COND on bcond instruction", p)
        }
        switch a {
        case ABEQ:
@@ -2737,7 +2737,7 @@ func olhrr(ctxt *obj.Link, i int, b int, r int, sc int) uint32 {
 
 func ofsr(ctxt *obj.Link, a int, r int, v int32, b int, sc int, p *obj.Prog) uint32 {
        if sc&C_SBIT != 0 {
-               ctxt.Diag(".nil on FLDR/FSTR instruction")
+               ctxt.Diag(".nil on FLDR/FSTR instruction: %v", p)
        }
        o := ((uint32(sc) & C_SCOND) ^ C_SCOND_XOR) << 28
        if sc&C_PBIT == 0 {

diff --git a/src/cmd/internal/obj/arm64/a.out.go b/src/cmd/internal/obj/arm64/a.out.go
index d3e1e5ecbbac06fa03a2ad8847858579febeb1d8..f459483cce330d2480451749efc060d30597bace 100644 (file)
--- a/src/cmd/internal/obj/arm64/a.out.go
+++ b/src/cmd/internal/obj/arm64/a.out.go
@@ -655,15 +655,8 @@ const (
        AUCVTFS
        AUCVTFWD
        AUCVTFWS
-       AHISTORY
-       ANAME
        AWORD
-       ADYNT
-       AINIT
        ADWORD
-       ASIGNAME
-       AGOK
-       AEND
        AFCSELS
        AFCSELD
        AFMAXS

diff --git a/src/cmd/internal/obj/arm64/anames.go b/src/cmd/internal/obj/arm64/anames.go
index 486d4698a1955b575b8ac53fbc9cc0318ba6d336..4ee4043af7525a099fb34ee3c61668b8dcca3671 100644 (file)
--- a/src/cmd/internal/obj/arm64/anames.go
+++ b/src/cmd/internal/obj/arm64/anames.go
@@ -312,15 +312,8 @@ var Anames = []string{
        "UCVTFS",
        "UCVTFWD",
        "UCVTFWS",
-       "HISTORY",
-       "NAME",
        "WORD",
-       "DYNT",
-       "INIT",
        "DWORD",
-       "SIGNAME",
-       "GOK",
-       "END",
        "FCSELS",
        "FCSELD",
        "FMAXS",

diff --git a/src/cmd/internal/obj/arm64/asm7.go b/src/cmd/internal/obj/arm64/asm7.go
index dca7a7f832327d5f6cb7c2cf534c38c084221c2e..162acd255528719ecd250c5bedb1f67b226614ee 100644 (file)
--- a/src/cmd/internal/obj/arm64/asm7.go
+++ b/src/cmd/internal/obj/arm64/asm7.go
@@ -693,7 +693,7 @@ func flushpool(ctxt *obj.Link, p *obj.Prog, skip int) {
                        q.Link = ctxt.Blitrl
                        q.Lineno = p.Lineno
                        ctxt.Blitrl = q
-               } else if p.Pc+int64(pool.size)-int64(pool.start) < 1024*1024 {
+               } else if p.Pc+int64(pool.size)-int64(pool.start) < maxPCDisp {
                        return
                }
 
@@ -826,9 +826,15 @@ func regoff(ctxt *obj.Link, a *obj.Addr) uint32 {
        return uint32(ctxt.Instoffset)
 }
 
+// Maximum PC-relative displacement.
+// The actual limit is ±2²⁰, but we are conservative
+// to avoid needing to recompute the literal pool flush points
+// as span-dependent jumps are enlarged.
+const maxPCDisp = 512 * 1024
+
+// ispcdisp reports whether v is a valid PC-relative displacement.
 func ispcdisp(v int32) bool {
-       /* pc-relative addressing will reach? */
-       return v >= -0xfffff && v <= 0xfffff && (v&3) == 0
+       return -maxPCDisp < v && v < maxPCDisp && v&3 == 0
 }
 
 func isaddcon(v int64) bool {
@@ -3654,7 +3660,8 @@ func brdist(ctxt *obj.Link, p *obj.Prog, preshift int, flen int, shift int) int6
                v >>= uint(shift)
                t = int64(1) << uint(flen-1)
                if v < -t || v >= t {
-                       ctxt.Diag("branch too far\n%v", p)
+                       ctxt.Diag("branch too far %#x vs %#x [%p]\n%v\n%v", v, t, ctxt.Blitrl, p, p.Pcond)
+                       panic("branch too far")
                }
        }
 

diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go
index f3d1a9557a4b0e116a5d818a3e2cfaa59f01c2dd..2e6df2c2f87fe8db11536549c0f8db7e3481ac92 100644 (file)
--- a/src/cmd/internal/obj/link.go
+++ b/src/cmd/internal/obj/link.go
@@ -604,12 +604,13 @@ type Link struct {
        Autosize           int32
        Armsize            int32
        Pc                 int64
-       Diag               func(string, ...interface{})
+       DiagFunc           func(string, ...interface{})
        Mode               int
        Cursym             *LSym
        Version            int
        Textp              *LSym
        Etextp             *LSym
+       Errors             int
 
        // state for writing objects
        Text  *LSym
@@ -618,6 +619,11 @@ type Link struct {
        Edata *LSym
 }
 
+func (ctxt *Link) Diag(format string, args ...interface{}) {
+       ctxt.Errors++
+       ctxt.DiagFunc(format, args...)
+}
+
 // The smallest possible offset from the hardware stack pointer to a local
 // variable on the stack. Architectures that use a link register save its value
 // on the stack in the function prologue and so always have a pointer between

diff --git a/src/cmd/internal/obj/mips/a.out.go b/src/cmd/internal/obj/mips/a.out.go
index f271a876093bf58900ef4e7fd4501fc98c861524..282cb79e313b10ab5c49a364cdbc1f812c100193 100644 (file)
--- a/src/cmd/internal/obj/mips/a.out.go
+++ b/src/cmd/internal/obj/mips/a.out.go
@@ -114,7 +114,7 @@ const (
        REG_LO
 
        // co-processor 0 control registers
-       REG_M0 = obj.RBaseMIPS64 + 1024 + iota
+       REG_M0
        REG_M1
        REG_M2
        REG_M3
@@ -148,7 +148,7 @@ const (
        REG_M31
 
        // FPU control registers
-       REG_FCR0 = obj.RBaseMIPS64 + 2048 + iota
+       REG_FCR0
        REG_FCR1
        REG_FCR2
        REG_FCR3
@@ -181,6 +181,8 @@ const (
        REG_FCR30
        REG_FCR31
 
+       REG_LAST = REG_FCR31 // the last defined register
+
        REG_SPECIAL = REG_M0
 
        REGZERO  = REG_R0 /* set to zero */

diff --git a/src/cmd/internal/obj/mips/list0.go b/src/cmd/internal/obj/mips/list0.go
index 0807a62a8d046c95f652463c9000d977e783c1ec..40dc4605c9b36e225b72d21a45896033147cb36b 100644 (file)
--- a/src/cmd/internal/obj/mips/list0.go
+++ b/src/cmd/internal/obj/mips/list0.go
@@ -35,7 +35,7 @@ import (
 )
 
 func init() {
-       obj.RegisterRegister(obj.RBaseMIPS64, REG_FCR0+1024, Rconv)
+       obj.RegisterRegister(obj.RBaseMIPS64, REG_LAST&^1023+1024, Rconv)
        obj.RegisterOpcode(obj.ABaseMIPS64, Anames)
 }
 

diff --git a/src/cmd/internal/obj/util.go b/src/cmd/internal/obj/util.go
index ea59d4605e798b2c00c41f60eaeff00b2e44d091..459361cf48ee009f641f2b98f8d7573cb9e5e611 100644 (file)
--- a/src/cmd/internal/obj/util.go
+++ b/src/cmd/internal/obj/util.go
@@ -532,7 +532,7 @@ const (
        RBaseARM    = 3 * 1024
        RBasePPC64  = 4 * 1024  // range [4k, 8k)
        RBaseARM64  = 8 * 1024  // range [8k, 13k)
-       RBaseMIPS64 = 13 * 1024 // range [13k, 16k)
+       RBaseMIPS64 = 13 * 1024 // range [13k, 14k)
 )
 
 // RegisterRegister binds a pretty-printer (Rconv) for register

diff --git a/src/cmd/internal/obj/x86/a.out.go b/src/cmd/internal/obj/x86/a.out.go
index f163505fd0c718409e17644f1d9f4feca847f2eb..ca7b0cfdcad2f58acdfa6e3d53c4300e4ce11448 100644 (file)
--- a/src/cmd/internal/obj/x86/a.out.go
+++ b/src/cmd/internal/obj/x86/a.out.go
@@ -95,7 +95,11 @@ const (
        ADIVL
        ADIVW
        AENTER
+       AHADDPD
+       AHADDPS
        AHLT
+       AHSUBPD
+       AHSUBPS
        AIDIVB
        AIDIVL
        AIDIVW
@@ -187,7 +191,9 @@ const (
        APAUSE
        APOPAL
        APOPAW
-       APOPCNT
+       APOPCNTW
+       APOPCNTL
+       APOPCNTQ
        APOPFL
        APOPFW
        APOPL
@@ -514,10 +520,22 @@ const (
        AADDPS
        AADDSD
        AADDSS
+       AANDNL
+       AANDNQ
        AANDNPD
        AANDNPS
        AANDPD
        AANDPS
+       ABEXTRL
+       ABEXTRQ
+       ABLSIL
+       ABLSIQ
+       ABLSMSKL
+       ABLSMSKQ
+       ABLSRL
+       ABLSRQ
+       ABZHIL
+       ABZHIQ
        ACMPPD
        ACMPPS
        ACMPSD
@@ -555,6 +573,7 @@ const (
        AFXRSTOR64
        AFXSAVE
        AFXSAVE64
+       ALDDQU
        ALDMXCSR
        AMASKMOVOU
        AMASKMOVQ
@@ -591,6 +610,8 @@ const (
        AMULPS
        AMULSD
        AMULSS
+       AMULXL
+       AMULXQ
        AORPD
        AORPS
        APACKSSLW
@@ -604,15 +625,15 @@ const (
        APADDUSB
        APADDUSW
        APADDW
+       APAND
        APANDB
        APANDL
+       APANDN
        APANDSB
        APANDSW
        APANDUSB
        APANDUSW
        APANDW
-       APAND
-       APANDN
        APAVGB
        APAVGW
        APCMPEQB
@@ -621,10 +642,14 @@ const (
        APCMPGTB
        APCMPGTL
        APCMPGTW
-       APEXTRW
+       APDEPL
+       APDEPQ
+       APEXTL
+       APEXTQ
        APEXTRB
        APEXTRD
        APEXTRQ
+       APEXTRW
        APFACC
        APFADD
        APFCMPEQ
@@ -636,42 +661,63 @@ const (
        APFNACC
        APFPNACC
        APFRCP
-       APFRCPIT1
        APFRCPI2T
+       APFRCPIT1
        APFRSQIT1
        APFRSQRT
        APFSUB
        APFSUBR
-       APINSRW
+       APHADDD
+       APHADDSW
+       APHADDW
+       APHMINPOSUW
+       APHSUBD
+       APHSUBSW
+       APHSUBW
        APINSRB
        APINSRD
        APINSRQ
+       APINSRW
        APMADDWL
        APMAXSW
        APMAXUB
        APMINSW
        APMINUB
        APMOVMSKB
+       APMOVSXBD
+       APMOVSXBQ
+       APMOVSXBW
+       APMOVSXDQ
+       APMOVSXWD
+       APMOVSXWQ
+       APMOVZXBD
+       APMOVZXBQ
+       APMOVZXBW
+       APMOVZXDQ
+       APMOVZXWD
+       APMOVZXWQ
+       APMULDQ
        APMULHRW
        APMULHUW
        APMULHW
+       APMULLD
        APMULLW
        APMULULQ
        APOR
        APSADBW
+       APSHUFB
        APSHUFHW
        APSHUFL
        APSHUFLW
        APSHUFW
-       APSHUFB
-       APSLLO
        APSLLL
+       APSLLO
        APSLLQ
        APSLLW
        APSRAL
        APSRAW
-       APSRLO
        APSRLL
+       APSRLO
        APSRLQ
        APSRLW
        APSUBB
@@ -696,6 +742,12 @@ const (
        ARCPSS
        ARSQRTPS
        ARSQRTSS
+       ASARXL
+       ASARXQ
+       ASHLXL
+       ASHLXQ
+       ASHRXL
+       ASHRXQ
        ASHUFPD
        ASHUFPS
        ASQRTPD
@@ -755,9 +807,9 @@ const (
        APCLMULQDQ
 
        AVZEROUPPER
-       AMOVHDU
-       AMOVNTHD
-       AMOVHDA
+       AVMOVDQU
+       AVMOVNTDQ
+       AVMOVDQA
        AVPCMPEQB
        AVPXOR
        AVPMOVMSKB
@@ -870,6 +922,23 @@ const (
        REG_X14
        REG_X15
 
+       REG_Y0
+       REG_Y1
+       REG_Y2
+       REG_Y3
+       REG_Y4
+       REG_Y5
+       REG_Y6
+       REG_Y7
+       REG_Y8
+       REG_Y9
+       REG_Y10
+       REG_Y11
+       REG_Y12
+       REG_Y13
+       REG_Y14
+       REG_Y15
+
        REG_CS
        REG_SS
        REG_DS

diff --git a/src/cmd/internal/obj/x86/anames.go b/src/cmd/internal/obj/x86/anames.go
index 392899cf5f38b4d9df9bd42fb818a7e8c913880e..1875eae41811d07b2db59aa7a29bfa2e3290040a 100644 (file)
--- a/src/cmd/internal/obj/x86/anames.go
+++ b/src/cmd/internal/obj/x86/anames.go
@@ -57,7 +57,11 @@ var Anames = []string{
        "DIVL",
        "DIVW",
        "ENTER",
+       "HADDPD",
+       "HADDPS",
        "HLT",
+       "HSUBPD",
+       "HSUBPS",
        "IDIVB",
        "IDIVL",
        "IDIVW",
@@ -149,7 +153,9 @@ var Anames = []string{
        "PAUSE",
        "POPAL",
        "POPAW",
-       "POPCNT",
+       "POPCNTW",
+       "POPCNTL",
+       "POPCNTQ",
        "POPFL",
        "POPFW",
        "POPL",
@@ -457,10 +463,22 @@ var Anames = []string{
        "ADDPS",
        "ADDSD",
        "ADDSS",
+       "ANDNL",
+       "ANDNQ",
        "ANDNPD",
        "ANDNPS",
        "ANDPD",
        "ANDPS",
+       "BEXTRL",
+       "BEXTRQ",
+       "BLSIL",
+       "BLSIQ",
+       "BLSMSKL",
+       "BLSMSKQ",
+       "BLSRL",
+       "BLSRQ",
+       "BZHIL",
+       "BZHIQ",
        "CMPPD",
        "CMPPS",
        "CMPSD",
@@ -498,6 +516,7 @@ var Anames = []string{
        "FXRSTOR64",
        "FXSAVE",
        "FXSAVE64",
+       "LDDQU",
        "LDMXCSR",
        "MASKMOVOU",
        "MASKMOVQ",
@@ -534,6 +553,8 @@ var Anames = []string{
        "MULPS",
        "MULSD",
        "MULSS",
+       "MULXL",
+       "MULXQ",
        "ORPD",
        "ORPS",
        "PACKSSLW",
@@ -547,15 +568,15 @@ var Anames = []string{
        "PADDUSB",
        "PADDUSW",
        "PADDW",
+       "PAND",
        "PANDB",
        "PANDL",
+       "PANDN",
        "PANDSB",
        "PANDSW",
        "PANDUSB",
        "PANDUSW",
        "PANDW",
-       "PAND",
-       "PANDN",
        "PAVGB",
        "PAVGW",
        "PCMPEQB",
@@ -564,10 +585,14 @@ var Anames = []string{
        "PCMPGTB",
        "PCMPGTL",
        "PCMPGTW",
-       "PEXTRW",
+       "PDEPL",
+       "PDEPQ",
+       "PEXTL",
+       "PEXTQ",
        "PEXTRB",
        "PEXTRD",
        "PEXTRQ",
+       "PEXTRW",
        "PFACC",
        "PFADD",
        "PFCMPEQ",
@@ -579,42 +604,63 @@ var Anames = []string{
        "PFNACC",
        "PFPNACC",
        "PFRCP",
-       "PFRCPIT1",
        "PFRCPI2T",
+       "PFRCPIT1",
        "PFRSQIT1",
        "PFRSQRT",
        "PFSUB",
        "PFSUBR",
-       "PINSRW",
+       "PHADDD",
+       "PHADDSW",
+       "PHADDW",
+       "PHMINPOSUW",
+       "PHSUBD",
+       "PHSUBSW",
+       "PHSUBW",
        "PINSRB",
        "PINSRD",
        "PINSRQ",
+       "PINSRW",
        "PMADDWL",
        "PMAXSW",
        "PMAXUB",
        "PMINSW",
        "PMINUB",
        "PMOVMSKB",
+       "PMOVSXBD",
+       "PMOVSXBQ",
+       "PMOVSXBW",
+       "PMOVSXDQ",
+       "PMOVSXWD",
+       "PMOVSXWQ",
+       "PMOVZXBD",
+       "PMOVZXBQ",
+       "PMOVZXBW",
+       "PMOVZXDQ",
+       "PMOVZXWD",
+       "PMOVZXWQ",
+       "PMULDQ",
        "PMULHRW",
        "PMULHUW",
        "PMULHW",
+       "PMULLD",
        "PMULLW",
        "PMULULQ",
        "POR",
        "PSADBW",
+       "PSHUFB",
        "PSHUFHW",
        "PSHUFL",
        "PSHUFLW",
        "PSHUFW",
-       "PSHUFB",
-       "PSLLO",
        "PSLLL",
+       "PSLLO",
        "PSLLQ",
        "PSLLW",
        "PSRAL",
        "PSRAW",
-       "PSRLO",
        "PSRLL",
+       "PSRLO",
        "PSRLQ",
        "PSRLW",
        "PSUBB",
@@ -639,6 +685,12 @@ var Anames = []string{
        "RCPSS",
        "RSQRTPS",
        "RSQRTSS",
+       "SARXL",
+       "SARXQ",
+       "SHLXL",
+       "SHLXQ",
+       "SHRXL",
+       "SHRXQ",
        "SHUFPD",
        "SHUFPS",
        "SQRTPD",
@@ -690,9 +742,9 @@ var Anames = []string{
        "PSHUFD",
        "PCLMULQDQ",
        "VZEROUPPER",
-       "MOVHDU",
-       "MOVNTHD",
-       "MOVHDA",
+       "VMOVDQU",
+       "VMOVNTDQ",
+       "VMOVDQA",
        "VPCMPEQB",
        "VPXOR",
        "VPMOVMSKB",

diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go
index 8d0f86681f252b412fc15aceda249e90e5b782c4..4577ed79259cd13286f8c2123b875aabedd0bdf6 100644 (file)
--- a/src/cmd/internal/obj/x86/asm6.go
+++ b/src/cmd/internal/obj/x86/asm6.go
@@ -148,6 +148,8 @@ const (
        Ymm
        Yxr
        Yxm
+       Yyr
+       Yym
        Ytls
        Ytextsize
        Yindir
@@ -181,7 +183,6 @@ const (
        Zm_r
        Zm2_r
        Zm_r_xm
-       Zm_r_xm_vex
        Zm_r_i_xm
        Zm_r_3d
        Zm_r_xm_nr
@@ -195,8 +196,6 @@ const (
        Zpseudo
        Zr_m
        Zr_m_xm
-       Zr_m_xm_vex
-       Zr_r_r_vex
        Zrp_
        Z_ib
        Z_il
@@ -206,29 +205,32 @@ const (
        Zil_rr
        Zclr
        Zbyte
+       Zvex_rm_v_r
+       Zvex_r_v_rm
+       Zvex_v_rm_r
        Zmax
 )
 
 const (
-       Px    = 0
-       Px1   = 1    // symbolic; exact value doesn't matter
-       P32   = 0x32 /* 32-bit only */
-       Pe    = 0x66 /* operand escape */
-       Pm    = 0x0f /* 2byte opcode escape */
-       Pq    = 0xff /* both escapes: 66 0f */
-       Pb    = 0xfe /* byte operands */
-       Pf2   = 0xf2 /* xmm escape 1: f2 0f */
-       Pf3   = 0xf3 /* xmm escape 2: f3 0f */
-       Pq3   = 0x67 /* xmm escape 3: 66 48 0f */
-       Pfw   = 0xf4 /* Pf3 with Rex.w: f3 48 0f */
-       Pvex1 = 0xc5 /* 66.0f escape, vex encoding */
-       Pvex2 = 0xc6 /* f3.0f escape, vex encoding */
-       Pvex3 = 0xc7 /* 66.0f38 escape, vex encoding */
-       Pw    = 0x48 /* Rex.w */
-       Pw8   = 0x90 // symbolic; exact value doesn't matter
-       Py    = 0x80 /* defaults to 64-bit mode */
-       Py1   = 0x81 // symbolic; exact value doesn't matter
-       Py3   = 0x83 // symbolic; exact value doesn't matter
+       Px   = 0
+       Px1  = 1    // symbolic; exact value doesn't matter
+       P32  = 0x32 /* 32-bit only */
+       Pe   = 0x66 /* operand escape */
+       Pm   = 0x0f /* 2byte opcode escape */
+       Pq   = 0xff /* both escapes: 66 0f */
+       Pb   = 0xfe /* byte operands */
+       Pf2  = 0xf2 /* xmm escape 1: f2 0f */
+       Pf3  = 0xf3 /* xmm escape 2: f3 0f */
+       Pef3 = 0xf5 /* xmm escape 2 with 16-bit prefix: 66 f3 0f */
+       Pq3  = 0x67 /* xmm escape 3: 66 48 0f */
+       Pq4  = 0x68 /* xmm escape 4: 66 0F 38 */
+       Pfw  = 0xf4 /* Pf3 with Rex.w: f3 48 0f */
+       Pw   = 0x48 /* Rex.w */
+       Pw8  = 0x90 // symbolic; exact value doesn't matter
+       Py   = 0x80 /* defaults to 64-bit mode */
+       Py1  = 0x81 // symbolic; exact value doesn't matter
+       Py3  = 0x83 // symbolic; exact value doesn't matter
+       Pvex = 0x84 // symbolic: exact value doesn't matter
 
        Rxw = 1 << 3 /* =1, 64-bit operand size */
        Rxr = 1 << 2 /* extend modrm reg */
@@ -236,6 +238,75 @@ const (
        Rxb = 1 << 0 /* extend modrm r/m, sib base, or opcode reg */
 )
 
+const (
+       // Encoding for VEX prefix in tables.
+       // The P, L, and W fields are chosen to match
+       // their eventual locations in the VEX prefix bytes.
+
+       // P field - 2 bits
+       vex66 = 1 << 0
+       vexF3 = 2 << 0
+       vexF2 = 3 << 0
+       // L field - 1 bit
+       vexLZ  = 0 << 2
+       vexLIG = 0 << 2
+       vex128 = 0 << 2
+       vex256 = 1 << 2
+       // W field - 1 bit
+       vexWIG = 0 << 7
+       vexW0  = 0 << 7
+       vexW1  = 1 << 7
+       // M field - 5 bits, but mostly reserved; we can store up to 4
+       vex0F   = 1 << 3
+       vex0F38 = 2 << 3
+       vex0F3A = 3 << 3
+
+       // Combinations used in the manual.
+       VEX_128_0F_WIG      = vex128 | vex0F | vexWIG
+       VEX_128_66_0F_W0    = vex128 | vex66 | vex0F | vexW0
+       VEX_128_66_0F_W1    = vex128 | vex66 | vex0F | vexW1
+       VEX_128_66_0F_WIG   = vex128 | vex66 | vex0F | vexWIG
+       VEX_128_66_0F38_W0  = vex128 | vex66 | vex0F38 | vexW0
+       VEX_128_66_0F38_W1  = vex128 | vex66 | vex0F38 | vexW1
+       VEX_128_66_0F38_WIG = vex128 | vex66 | vex0F38 | vexWIG
+       VEX_128_66_0F3A_W0  = vex128 | vex66 | vex0F3A | vexW0
+       VEX_128_66_0F3A_W1  = vex128 | vex66 | vex0F3A | vexW1
+       VEX_128_66_0F3A_WIG = vex128 | vex66 | vex0F3A | vexWIG
+       VEX_128_F2_0F_WIG   = vex128 | vexF2 | vex0F | vexWIG
+       VEX_128_F3_0F_WIG   = vex128 | vexF3 | vex0F | vexWIG
+       VEX_256_66_0F_WIG   = vex256 | vex66 | vex0F | vexWIG
+       VEX_256_66_0F38_W0  = vex256 | vex66 | vex0F38 | vexW0
+       VEX_256_66_0F38_W1  = vex256 | vex66 | vex0F38 | vexW1
+       VEX_256_66_0F38_WIG = vex256 | vex66 | vex0F38 | vexWIG
+       VEX_256_66_0F3A_W0  = vex256 | vex66 | vex0F3A | vexW0
+       VEX_256_66_0F3A_W1  = vex256 | vex66 | vex0F3A | vexW1
+       VEX_256_66_0F3A_WIG = vex256 | vex66 | vex0F3A | vexWIG
+       VEX_256_F2_0F_WIG   = vex256 | vexF2 | vex0F | vexWIG
+       VEX_256_F3_0F_WIG   = vex256 | vexF3 | vex0F | vexWIG
+       VEX_LIG_0F_WIG      = vexLIG | vex0F | vexWIG
+       VEX_LIG_66_0F_WIG   = vexLIG | vex66 | vex0F | vexWIG
+       VEX_LIG_66_0F38_W0  = vexLIG | vex66 | vex0F38 | vexW0
+       VEX_LIG_66_0F38_W1  = vexLIG | vex66 | vex0F38 | vexW1
+       VEX_LIG_66_0F3A_WIG = vexLIG | vex66 | vex0F3A | vexWIG
+       VEX_LIG_F2_0F_W0    = vexLIG | vexF2 | vex0F | vexW0
+       VEX_LIG_F2_0F_W1    = vexLIG | vexF2 | vex0F | vexW1
+       VEX_LIG_F2_0F_WIG   = vexLIG | vexF2 | vex0F | vexWIG
+       VEX_LIG_F3_0F_W0    = vexLIG | vexF3 | vex0F | vexW0
+       VEX_LIG_F3_0F_W1    = vexLIG | vexF3 | vex0F | vexW1
+       VEX_LIG_F3_0F_WIG   = vexLIG | vexF3 | vex0F | vexWIG
+       VEX_LZ_0F_WIG       = vexLZ | vex0F | vexWIG
+       VEX_LZ_0F38_W0      = vexLZ | vex0F38 | vexW0
+       VEX_LZ_0F38_W1      = vexLZ | vex0F38 | vexW1
+       VEX_LZ_66_0F38_W0   = vexLZ | vex66 | vex0F38 | vexW0
+       VEX_LZ_66_0F38_W1   = vexLZ | vex66 | vex0F38 | vexW1
+       VEX_LZ_F2_0F38_W0   = vexLZ | vexF2 | vex0F38 | vexW0
+       VEX_LZ_F2_0F38_W1   = vexLZ | vexF2 | vex0F38 | vexW1
+       VEX_LZ_F2_0F3A_W0   = vexLZ | vexF2 | vex0F3A | vexW0
+       VEX_LZ_F2_0F3A_W1   = vexLZ | vexF2 | vex0F3A | vexW1
+       VEX_LZ_F3_0F38_W0   = vexLZ | vexF3 | vex0F38 | vexW0
+       VEX_LZ_F3_0F38_W1   = vexLZ | vexF3 | vex0F38 | vexW1
+)
+
 var ycover [Ymax * Ymax]uint8
 
 var reg [MAXREG]int
@@ -606,6 +677,10 @@ var yxm = []ytab{
        {Yxm, Ynone, Yxr, Zm_r_xm, 1},
 }
 
+var yxm_q4 = []ytab{
+       {Yxm, Ynone, Yxr, Zm_r, 1},
+}
+
 var yxcvm1 = []ytab{
        {Yxm, Ynone, Yxr, Zm_r_xm, 2},
        {Yxm, Ynone, Ymr, Zm_r_xm, 2},
@@ -630,20 +705,6 @@ var yxr_ml = []ytab{
        {Yxr, Ynone, Yml, Zr_m_xm, 1},
 }
 
-var yxr_ml_vex = []ytab{
-       {Yxr, Ynone, Yml, Zr_m_xm_vex, 1},
-}
-
-var yml_xr_vex = []ytab{
-       {Yml, Ynone, Yxr, Zm_r_xm_vex, 1},
-       {Yxr, Ynone, Yxr, Zm_r_xm_vex, 1},
-}
-
-var yxm_xm_xm = []ytab{
-       {Yxr, Yxr, Yxr, Zr_r_r_vex, 1},
-       {Yxm, Yxr, Yxr, Zr_r_r_vex, 1},
-}
-
 var ymr = []ytab{
        {Ymr, Ynone, Ymr, Zm_r, 1},
 }
@@ -660,11 +721,6 @@ var yxcmpi = []ytab{
        {Yxm, Yxr, Yi8, Zm_r_i_xm, 2},
 }
 
-var yxmov_vex = []ytab{
-       {Yxm, Ynone, Yxr, Zm_r_xm_vex, 1},
-       {Yxr, Ynone, Yxm, Zr_m_xm_vex, 1},
-}
-
 var yxmov = []ytab{
        {Yxm, Ynone, Yxr, Zm_r_xm, 1},
        {Yxr, Ynone, Yxm, Zr_m_xm, 1},
@@ -743,10 +799,6 @@ var ymskb = []ytab{
        {Ymr, Ynone, Yrl, Zm_r_xm, 1},
 }
 
-var ymskb_vex = []ytab{
-       {Yxr, Ynone, Yrl, Zm_r_xm_vex, 2},
-}
-
 var ycrc32l = []ytab{
        {Yml, Ynone, Yrl, Zlitm_r, 0},
 }
@@ -771,6 +823,81 @@ var yxabort = []ytab{
        {Yu8, Ynone, Ynone, Zib_, 1},
 }
 
+var ylddqu = []ytab{
+       {Ym, Ynone, Yxr, Zm_r, 1},
+}
+
+// VEX instructions that come in two forms:
+//     VTHING xmm2/m128, xmmV, xmm1
+//     VTHING ymm2/m256, ymmV, ymm1
+// The opcode array in the corresponding Optab entry
+// should contain the (VEX prefixes, opcode byte) pair
+// for each of the two forms.
+// For example, the entries for VPXOR are:
+//
+//     VPXOR xmm2/m128, xmmV, xmm1
+//     VEX.NDS.128.66.0F.WIG EF /r
+//
+//     VPXOR ymm2/m256, ymmV, ymm1
+//     VEX.NDS.256.66.0F.WIG EF /r
+//
+// The NDS/NDD/DDS part can be dropped, producing this
+// Optab entry:
+//
+//     {AVPXOR, yvex_xy3, Pvex, [23]uint8{VEX_128_66_0F_WIG, 0xEF, VEX_256_66_0F_WIG, 0xEF}}
+//
+var yvex_xy3 = []ytab{
+       {Yxm, Yxr, Yxr, Zvex_rm_v_r, 2},
+       {Yym, Yyr, Yyr, Zvex_rm_v_r, 2},
+}
+
+var yvex_r3 = []ytab{
+       {Yml, Yrl, Yrl, Zvex_rm_v_r, 2},
+       {Yml, Yrl, Yrl, Zvex_rm_v_r, 2},
+}
+
+var yvex_vmr3 = []ytab{
+       {Yrl, Yml, Yrl, Zvex_v_rm_r, 2},
+       {Yrl, Yml, Yrl, Zvex_v_rm_r, 2},
+}
+
+var yvex_xy2 = []ytab{
+       {Yxm, Ynone, Yxr, Zvex_rm_v_r, 2},
+       {Yym, Ynone, Yyr, Zvex_rm_v_r, 2},
+}
+
+var yvex_xyr2 = []ytab{
+       {Yxr, Ynone, Yrl, Zvex_rm_v_r, 2},
+       {Yyr, Ynone, Yrl, Zvex_rm_v_r, 2},
+}
+
+var yvex_vmovdqa = []ytab{
+       {Yxm, Ynone, Yxr, Zvex_rm_v_r, 2},
+       {Yxr, Ynone, Yxm, Zvex_r_v_rm, 2},
+       {Yym, Ynone, Yyr, Zvex_rm_v_r, 2},
+       {Yyr, Ynone, Yym, Zvex_r_v_rm, 2},
+}
+
+var yvex_vmovntdq = []ytab{
+       {Yxr, Ynone, Ym, Zvex_r_v_rm, 2},
+       {Yyr, Ynone, Ym, Zvex_r_v_rm, 2},
+}
+
+var yvex_vpbroadcast = []ytab{
+       {Yxm, Ynone, Yxr, Zvex_rm_v_r, 2},
+       {Yxm, Ynone, Yyr, Zvex_rm_v_r, 2},
+}
+
+var yvex_xxmyxm = []ytab{
+       {Yxr, Ynone, Yxm, Zvex_r_v_rm, 2},
+       {Yyr, Ynone, Yxm, Zvex_r_v_rm, 2},
+}
+
+var ymmxmm0f38 = []ytab{
+       {Ymm, Ynone, Ymr, Zlitm_r, 3},
+       {Yxm, Ynone, Yxr, Zlitm_r, 5},
+}
+
 /*
  * You are doasm, holding in your hand a Prog* with p->as set to, say, ACRC32,
  * and p->from and p->to as operands (Addr*).  The linker scans optab to find
@@ -1044,9 +1171,14 @@ var optab =
        {AJPC, yjcond, Px, [23]uint8{0x7b, 0x8b}},
        {AJPL, yjcond, Px, [23]uint8{0x79, 0x89}},
        {AJPS, yjcond, Px, [23]uint8{0x7a, 0x8a}},
+       {AHADDPD, yxm, Pq, [23]uint8{0x7c}},
+       {AHADDPS, yxm, Pf2, [23]uint8{0x7c}},
+       {AHSUBPD, yxm, Pq, [23]uint8{0x7d}},
+       {AHSUBPS, yxm, Pf2, [23]uint8{0x7d}},
        {ALAHF, ynone, Px, [23]uint8{0x9f}},
        {ALARL, yml_rl, Pm, [23]uint8{0x02}},
        {ALARW, yml_rl, Pq, [23]uint8{0x02}},
+       {ALDDQU, ylddqu, Pf2, [23]uint8{0xf0}},
        {ALDMXCSR, ysvrs, Pm, [23]uint8{0xae, 02, 0xae, 02}},
        {ALEAL, ym_rl, Px, [23]uint8{0x8d}},
        {ALEAQ, ym_rl, Pw, [23]uint8{0x8d}},
@@ -1191,6 +1323,13 @@ var optab =
        {APFRSQRT, ymfp, Px, [23]uint8{0x97}},
        {APFSUB, ymfp, Px, [23]uint8{0x9a}},
        {APFSUBR, ymfp, Px, [23]uint8{0xaa}},
+       {APHADDD, ymmxmm0f38, Px, [23]uint8{0x0F, 0x38, 0x02, 0, 0x66, 0x0F, 0x38, 0x02, 0}},
+       {APHADDSW, yxm_q4, Pq4, [23]uint8{0x03}},
+       {APHADDW, yxm_q4, Pq4, [23]uint8{0x01}},
+       {APHMINPOSUW, yxm_q4, Pq4, [23]uint8{0x41}},
+       {APHSUBD, yxm_q4, Pq4, [23]uint8{0x06}},
+       {APHSUBSW, yxm_q4, Pq4, [23]uint8{0x07}},
+       {APHSUBW, yxm_q4, Pq4, [23]uint8{0x05}},
        {APINSRW, yinsrw, Pq, [23]uint8{0xc4, 00}},
        {APINSRB, yinsr, Pq, [23]uint8{0x3a, 0x20, 00}},
        {APINSRD, yinsr, Pq, [23]uint8{0x3a, 0x22, 00}},
@@ -1201,14 +1340,30 @@ var optab =
        {APMINSW, yxm, Pe, [23]uint8{0xea}},
        {APMINUB, yxm, Pe, [23]uint8{0xda}},
        {APMOVMSKB, ymskb, Px, [23]uint8{Pe, 0xd7, 0xd7}},
+       {APMOVSXBD, yxm_q4, Pq4, [23]uint8{0x21}},
+       {APMOVSXBQ, yxm_q4, Pq4, [23]uint8{0x22}},
+       {APMOVSXBW, yxm_q4, Pq4, [23]uint8{0x20}},
+       {APMOVSXDQ, yxm_q4, Pq4, [23]uint8{0x25}},
+       {APMOVSXWD, yxm_q4, Pq4, [23]uint8{0x23}},
+       {APMOVSXWQ, yxm_q4, Pq4, [23]uint8{0x24}},
+       {APMOVZXBD, yxm_q4, Pq4, [23]uint8{0x31}},
+       {APMOVZXBQ, yxm_q4, Pq4, [23]uint8{0x32}},
+       {APMOVZXBW, yxm_q4, Pq4, [23]uint8{0x30}},
+       {APMOVZXDQ, yxm_q4, Pq4, [23]uint8{0x35}},
+       {APMOVZXWD, yxm_q4, Pq4, [23]uint8{0x33}},
+       {APMOVZXWQ, yxm_q4, Pq4, [23]uint8{0x34}},
+       {APMULDQ, yxm_q4, Pq4, [23]uint8{0x28}},
        {APMULHRW, ymfp, Px, [23]uint8{0xb7}},
        {APMULHUW, ymm, Py1, [23]uint8{0xe4, Pe, 0xe4}},
        {APMULHW, ymm, Py1, [23]uint8{0xe5, Pe, 0xe5}},
+       {APMULLD, yxm_q4, Pq4, [23]uint8{0x40}},
        {APMULLW, ymm, Py1, [23]uint8{0xd5, Pe, 0xd5}},
        {APMULULQ, ymm, Py1, [23]uint8{0xf4, Pe, 0xf4}},
        {APOPAL, ynone, P32, [23]uint8{0x61}},
        {APOPAW, ynone, Pe, [23]uint8{0x61}},
-       {APOPCNT, yml_rl, Pfw, [23]uint8{0xb8}},
+       {APOPCNTW, yml_rl, Pef3, [23]uint8{0xb8}},
+       {APOPCNTL, yml_rl, Pf3, [23]uint8{0xb8}},
+       {APOPCNTQ, yml_rl, Pfw, [23]uint8{0xb8}},
        {APOPFL, ynone, P32, [23]uint8{0x9d}},
        {APOPFQ, ynone, Py, [23]uint8{0x9d}},
        {APOPFW, ynone, Pe, [23]uint8{0x9d}},
@@ -1528,16 +1683,37 @@ var optab =
        {AROUNDSS, yaes2, Pq, [23]uint8{0x3a, 0x0a, 0}},
        {APSHUFD, yxshuf, Pq, [23]uint8{0x70, 0}},
        {APCLMULQDQ, yxshuf, Pq, [23]uint8{0x3a, 0x44, 0}},
+
+       {AANDNL, yvex_r3, Pvex, [23]uint8{VEX_LZ_0F38_W0, 0xF2}},
+       {AANDNQ, yvex_r3, Pvex, [23]uint8{VEX_LZ_0F38_W1, 0xF2}},
+       {ABEXTRL, yvex_vmr3, Pvex, [23]uint8{VEX_LZ_0F38_W0, 0xF7}},
+       {ABEXTRQ, yvex_vmr3, Pvex, [23]uint8{VEX_LZ_0F38_W1, 0xF7}},
+       {ABZHIL, yvex_vmr3, Pvex, [23]uint8{VEX_LZ_0F38_W0, 0xF5}},
+       {ABZHIQ, yvex_vmr3, Pvex, [23]uint8{VEX_LZ_0F38_W1, 0xF5}},
+       {AMULXL, yvex_r3, Pvex, [23]uint8{VEX_LZ_F2_0F38_W0, 0xF6}},
+       {AMULXQ, yvex_r3, Pvex, [23]uint8{VEX_LZ_F2_0F38_W1, 0xF6}},
+       {APDEPL, yvex_r3, Pvex, [23]uint8{VEX_LZ_F2_0F38_W0, 0xF5}},
+       {APDEPQ, yvex_r3, Pvex, [23]uint8{VEX_LZ_F2_0F38_W1, 0xF5}},
+       {APEXTL, yvex_r3, Pvex, [23]uint8{VEX_LZ_F3_0F38_W0, 0xF5}},
+       {APEXTQ, yvex_r3, Pvex, [23]uint8{VEX_LZ_F3_0F38_W1, 0xF5}},
+       {ASARXL, yvex_vmr3, Pvex, [23]uint8{VEX_LZ_F3_0F38_W0, 0xF7}},
+       {ASARXQ, yvex_vmr3, Pvex, [23]uint8{VEX_LZ_F3_0F38_W1, 0xF7}},
+       {ASHLXL, yvex_vmr3, Pvex, [23]uint8{VEX_LZ_66_0F38_W0, 0xF7}},
+       {ASHLXQ, yvex_vmr3, Pvex, [23]uint8{VEX_LZ_66_0F38_W1, 0xF7}},
+       {ASHRXL, yvex_vmr3, Pvex, [23]uint8{VEX_LZ_F2_0F38_W0, 0xF7}},
+       {ASHRXQ, yvex_vmr3, Pvex, [23]uint8{VEX_LZ_F2_0F38_W1, 0xF7}},
+
        {AVZEROUPPER, ynone, Px, [23]uint8{0xc5, 0xf8, 0x77}},
-       {AMOVHDU, yxmov_vex, Pvex2, [23]uint8{0x6f, 0x7f}},
-       {AMOVNTHD, yxr_ml_vex, Pvex1, [23]uint8{0xe7}},
-       {AMOVHDA, yxmov_vex, Pvex1, [23]uint8{0x6f, 0x7f}},
-       {AVPCMPEQB, yxm_xm_xm, Pvex1, [23]uint8{0x74, 0x74}},
-       {AVPXOR, yxm_xm_xm, Pvex1, [23]uint8{0xef, 0xef}},
-       {AVPMOVMSKB, ymskb_vex, Pvex1, [23]uint8{0xd7}},
-       {AVPAND, yxm_xm_xm, Pvex1, [23]uint8{0xdb, 0xdb}},
-       {AVPBROADCASTB, yml_xr_vex, Pvex3, [23]uint8{0x78, 0x78}},
-       {AVPTEST, yml_xr_vex, Pvex3, [23]uint8{0x17, 0x17}},
+       {AVMOVDQU, yvex_vmovdqa, Pvex, [23]uint8{VEX_128_F3_0F_WIG, 0x6F, VEX_128_F3_0F_WIG, 0x7F, VEX_256_F3_0F_WIG, 0x6F, VEX_256_F3_0F_WIG, 0x7F}},
+       {AVMOVDQA, yvex_vmovdqa, Pvex, [23]uint8{VEX_128_66_0F_WIG, 0x6F, VEX_128_66_0F_WIG, 0x7F, VEX_256_66_0F_WIG, 0x6F, VEX_256_66_0F_WIG, 0x7F}},
+       {AVMOVNTDQ, yvex_vmovntdq, Pvex, [23]uint8{VEX_128_66_0F_WIG, 0xE7, VEX_256_66_0F_WIG, 0xE7}},
+       {AVPCMPEQB, yvex_xy3, Pvex, [23]uint8{VEX_128_66_0F_WIG, 0x74, VEX_256_66_0F_WIG, 0x74}},
+       {AVPXOR, yvex_xy3, Pvex, [23]uint8{VEX_128_66_0F_WIG, 0xEF, VEX_256_66_0F_WIG, 0xEF}},
+       {AVPMOVMSKB, yvex_xyr2, Pvex, [23]uint8{VEX_128_66_0F_WIG, 0xD7, VEX_256_66_0F_WIG, 0xD7}},
+       {AVPAND, yvex_xy3, Pvex, [23]uint8{VEX_128_66_0F_WIG, 0xDB, VEX_256_66_0F_WIG, 0xDB}},
+       {AVPBROADCASTB, yvex_vpbroadcast, Pvex, [23]uint8{VEX_128_66_0F38_W0, 0x78, VEX_256_66_0F38_W0, 0x78}},
+       {AVPTEST, yvex_xy2, Pvex, [23]uint8{VEX_128_66_0F38_WIG, 0x17, VEX_256_66_0F38_WIG, 0x17}},
+
        {AXACQUIRE, ynone, Px, [23]uint8{0xf2}},
        {AXRELEASE, ynone, Px, [23]uint8{0xf3}},
        {AXBEGIN, yxbegin, Px, [23]uint8{0xc7, 0xf8}},
@@ -1684,6 +1860,7 @@ func span6(ctxt *obj.Link, s *obj.LSym) {
        var loop int32
        var m int
        var p *obj.Prog
+       errors := ctxt.Errors
        for {
                loop = 0
                for i = 0; i < len(s.R); i++ {
@@ -1795,6 +1972,9 @@ func span6(ctxt *obj.Link, s *obj.LSym) {
                if loop == 0 {
                        break
                }
+               if ctxt.Errors > errors {
+                       return
+               }
        }
 
        if ctxt.Headtype == obj.Hnacl {
@@ -1927,6 +2107,9 @@ func instinit() {
        ycover[Ym*Ymax+Yxm] = 1
        ycover[Yxr*Ymax+Yxm] = 1
 
+       ycover[Ym*Ymax+Yym] = 1
+       ycover[Yyr*Ymax+Yym] = 1
+
        for i := 0; i < MAXREG; i++ {
                reg[i] = -1
                if i >= REG_AL && i <= REG_R15B {
@@ -1961,6 +2144,12 @@ func instinit() {
                                regrex[i] = Rxr | Rxx | Rxb
                        }
                }
+               if i >= REG_Y0 && i <= REG_Y0+15 {
+                       reg[i] = (i - REG_Y0) & 7
+                       if i >= REG_Y0+8 {
+                               regrex[i] = Rxr | Rxx | Rxb
+                       }
+               }
 
                if i >= REG_CR+8 && i <= REG_CR+15 {
                        regrex[i] = Rxr
@@ -2112,6 +2301,31 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
                return Yxxx
 
        case obj.TYPE_MEM:
+               if a.Index == REG_SP {
+                       // Can't use SP as the index register
+                       return Yxxx
+               }
+               if ctxt.Asmode == 64 {
+                       switch a.Name {
+                       case obj.NAME_EXTERN, obj.NAME_STATIC, obj.NAME_GOTREF:
+                               // Global variables can't use index registers and their
+                               // base register is %rip (%rip is encoded as REG_NONE).
+                               if a.Reg != REG_NONE || a.Index != REG_NONE || a.Scale != 0 {
+                                       return Yxxx
+                               }
+                       case obj.NAME_AUTO, obj.NAME_PARAM:
+                               // These names must have a base of SP.  The old compiler
+                               // uses 0 for the base register.  SSA uses REG_SP.
+                               if a.Reg != REG_SP && a.Reg != 0 {
+                                       return Yxxx
+                               }
+                       case obj.NAME_NONE:
+                               // everything is ok
+                       default:
+                               // unknown name
+                               return Yxxx
+                       }
+               }
                return Ym
 
        case obj.TYPE_ADDR:
@@ -2297,6 +2511,24 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int {
                REG_X0 + 15:
                return Yxr
 
+       case REG_Y0 + 0,
+               REG_Y0 + 1,
+               REG_Y0 + 2,
+               REG_Y0 + 3,
+               REG_Y0 + 4,
+               REG_Y0 + 5,
+               REG_Y0 + 6,
+               REG_Y0 + 7,
+               REG_Y0 + 8,
+               REG_Y0 + 9,
+               REG_Y0 + 10,
+               REG_Y0 + 11,
+               REG_Y0 + 12,
+               REG_Y0 + 13,
+               REG_Y0 + 14,
+               REG_Y0 + 15:
+               return Yyr
+
        case REG_CS:
                return Ycs
        case REG_SS:
@@ -2597,7 +2829,7 @@ func asmandsz(ctxt *obj.Link, p *obj.Prog, a *obj.Addr, r int, rex int, m64 int)
                goto bad
 
        case obj.TYPE_REG:
-               if a.Reg < REG_AL || REG_X0+15 < a.Reg {
+               if a.Reg < REG_AL || REG_Y0+15 < a.Reg {
                        goto bad
                }
                if v != 0 {
@@ -3025,77 +3257,40 @@ var bpduff2 = []byte{
        0x48, 0x8b, 0x6d, 0x00, // MOVQ 0(BP), BP
 }
 
-// Assemble vex prefix, from 3 operands and prefix.
+// Emit VEX prefix and opcode byte.
+// The three addresses are the r/m, vvvv, and reg fields.
+// The reg and rm arguments appear in the same order as the
+// arguments to asmand, which typically follows the call to asmvex.
+// The final two arguments are the VEX prefix (see encoding above)
+// and the opcode byte.
 // For details about vex prefix see:
 // https://en.wikipedia.org/wiki/VEX_prefix#Technical_description
-func vexprefix(ctxt *obj.Link, to *obj.Addr, from *obj.Addr, from3 *obj.Addr, pref uint8) {
-       rexR := regrex[to.Reg]
-       rexB := regrex[from.Reg]
-       rexX := regrex[from.Index]
-       var prefBit uint8
-       // This will go into VEX.PP field.
-       if pref == Pvex1 || pref == Pvex3 {
-               prefBit = 1
-       } else if pref == Pvex2 {
-               prefBit = 2
-       } // TODO add Pvex0
-
-       if rexX == 0 && rexB == 0 && pref != Pvex3 { // 2-byte vex prefix
-               // In 2-byte case, first byte is always C5
+func asmvex(ctxt *obj.Link, rm, v, r *obj.Addr, vex, opcode uint8) {
+       ctxt.Vexflag = 1
+       rexR := regrex[r.Reg] & Rxr
+       rexB := regrex[rm.Reg] & Rxb
+       rexX := regrex[rm.Index] & Rxx
+       vexM := (vex >> 3) & 0xF
+       vexWLP := vex & 0x87
+       vexV := byte(0)
+       if v != nil {
+               vexV = byte(reg[v.Reg]|(regrex[v.Reg]&Rxr)<<1) & 0xF
+       }
+       vexV ^= 0xF
+       if vexM == 1 && (rexX|rexB) == 0 && vex&vexW1 == 0 {
+               // Can use 2-byte encoding.
                ctxt.Andptr[0] = 0xc5
-               ctxt.Andptr = ctxt.Andptr[1:]
-
-               if from3 == nil {
-                       // If this is a 2-operand instruction fill VEX.VVVV with 1111
-                       // We are also interested only in 256-bit version, so VEX.L=1
-                       ctxt.Andptr[0] = 0x7c
-               } else {
-                       // VEX.L=1
-                       ctxt.Andptr[0] = 0x4
-                       // VEX.VVVV (bits 3:6) is a inversed register number
-                       ctxt.Andptr[0] |= byte((^(from3.Reg - REG_X0))<<3) & 0x78
-               }
-
-               // VEX encodes REX.R as inversed upper bit
-               if rexR == 0 {
-                       ctxt.Andptr[0] |= 0x80
-               }
-               ctxt.Andptr[0] |= prefBit
-               ctxt.Andptr = ctxt.Andptr[1:]
-       } else { // 3-byte case
-               // First byte is always C$
+               ctxt.Andptr[1] = byte(rexR<<5) ^ 0x80 | vexV<<3 | vexWLP
+               ctxt.Andptr = ctxt.Andptr[2:]
+       } else {
+               // Must use 3-byte encoding.
                ctxt.Andptr[0] = 0xc4
-               ctxt.Andptr = ctxt.Andptr[1:]
-
-               // Encode VEX.mmmmm with prefix value, assume 0F,
-               // which encodes as 1, unless 0F38 was specified with pvex3.
-               ctxt.Andptr[0] = 0x1 // TODO handle 0F3A
-               if pref == Pvex3 {
-                       ctxt.Andptr[0] = 0x2
-               }
-
-               // REX.[RXB] are inverted and encoded in 3 upper bits
-               if rexR == 0 {
-                       ctxt.Andptr[0] |= 0x80
-               }
-               if rexX == 0 {
-                       ctxt.Andptr[0] |= 0x40
-               }
-               if rexB == 0 {
-                       ctxt.Andptr[0] |= 0x20
-               }
-               ctxt.Andptr = ctxt.Andptr[1:]
-
-               // Fill VEX.VVVV, same as 2-operand VEX instruction.
-               if from3 == nil {
-                       ctxt.Andptr[0] = 0x7c
-               } else {
-                       ctxt.Andptr[0] = 0x4
-                       ctxt.Andptr[0] |= byte((^(from3.Reg - REG_X0))<<3) & 0x78
-               }
-               ctxt.Andptr[0] |= prefBit
-               ctxt.Andptr = ctxt.Andptr[1:]
+               ctxt.Andptr[1] = (byte(rexR|rexX|rexB) << 5) ^ 0xE0 | vexM
+               ctxt.Andptr[2] = vexV<<3 | vexWLP
+               ctxt.Andptr = ctxt.Andptr[3:]
        }
+       ctxt.Andptr[0] = opcode
+       ctxt.Andptr = ctxt.Andptr[1:]
 }
 
 func doasm(ctxt *obj.Link, p *obj.Prog) {
@@ -3192,15 +3387,19 @@ func doasm(ctxt *obj.Link, p *obj.Prog) {
                                ctxt.Andptr[0] = Pm
                                ctxt.Andptr = ctxt.Andptr[1:]
 
-                       case Pq3: /* 16 bit escape, Rex.w, and opcode escape */
+                       case Pq3: /* 16 bit escape and opcode escape + REX.W */
+                               ctxt.Rexflag |= Pw
                                ctxt.Andptr[0] = Pe
                                ctxt.Andptr = ctxt.Andptr[1:]
-
-                               ctxt.Andptr[0] = Pw
-                               ctxt.Andptr = ctxt.Andptr[1:]
                                ctxt.Andptr[0] = Pm
                                ctxt.Andptr = ctxt.Andptr[1:]
 
+                       case Pq4: /*  66 0F 38 */
+                               ctxt.Andptr[0] = 0x66
+                               ctxt.Andptr[1] = 0x0F
+                               ctxt.Andptr[2] = 0x38
+                               ctxt.Andptr = ctxt.Andptr[3:]
+
                        case Pf2, /* xmm opcode escape */
                                Pf3:
                                ctxt.Andptr[0] = byte(o.prefix)
@@ -3209,11 +3408,17 @@ func doasm(ctxt *obj.Link, p *obj.Prog) {
                                ctxt.Andptr[0] = Pm
                                ctxt.Andptr = ctxt.Andptr[1:]
 
-                       case Pfw: /* first escape, Rex.w, and second escape */
+                       case Pef3:
+                               ctxt.Andptr[0] = Pe
+                               ctxt.Andptr = ctxt.Andptr[1:]
                                ctxt.Andptr[0] = Pf3
                                ctxt.Andptr = ctxt.Andptr[1:]
+                               ctxt.Andptr[0] = Pm
+                               ctxt.Andptr = ctxt.Andptr[1:]
 
-                               ctxt.Andptr[0] = Pw
+                       case Pfw: /* xmm opcode escape + REX.W */
+                               ctxt.Rexflag |= Pw
+                               ctxt.Andptr[0] = Pf3
                                ctxt.Andptr = ctxt.Andptr[1:]
                                ctxt.Andptr[0] = Pm
                                ctxt.Andptr = ctxt.Andptr[1:]
@@ -3340,13 +3545,6 @@ func doasm(ctxt *obj.Link, p *obj.Prog) {
                                mediaop(ctxt, o, op, int(yt.zoffset), z)
                                asmand(ctxt, p, &p.From, &p.To)
 
-                       case Zm_r_xm_vex:
-                               ctxt.Vexflag = 1
-                               vexprefix(ctxt, &p.To, &p.From, nil, o.prefix)
-                               ctxt.Andptr[0] = byte(op)
-                               ctxt.Andptr = ctxt.Andptr[1:]
-                               asmand(ctxt, p, &p.From, &p.To)
-
                        case Zm_r_xm_nr:
                                ctxt.Rexflag = 0
                                mediaop(ctxt, o, op, int(yt.zoffset), z)
@@ -3406,20 +3604,18 @@ func doasm(ctxt *obj.Link, p *obj.Prog) {
                                ctxt.Andptr = ctxt.Andptr[1:]
                                asmand(ctxt, p, &p.To, &p.From)
 
-                       case Zr_m_xm_vex:
-                               ctxt.Vexflag = 1
-                               vexprefix(ctxt, &p.From, &p.To, nil, o.prefix)
-                               ctxt.Andptr[0] = byte(op)
-                               ctxt.Andptr = ctxt.Andptr[1:]
-                               asmand(ctxt, p, &p.To, &p.From)
-
-                       case Zr_r_r_vex:
-                               ctxt.Vexflag = 1
-                               vexprefix(ctxt, &p.To, &p.From, p.From3, o.prefix)
-                               ctxt.Andptr[0] = byte(op)
-                               ctxt.Andptr = ctxt.Andptr[1:]
+                       case Zvex_rm_v_r:
+                               asmvex(ctxt, &p.From, p.From3, &p.To, o.op[z], o.op[z+1])
                                asmand(ctxt, p, &p.From, &p.To)
 
+                       case Zvex_v_rm_r:
+                               asmvex(ctxt, p.From3, &p.From, &p.To, o.op[z], o.op[z+1])
+                               asmand(ctxt, p, p.From3, &p.To)
+
+                       case Zvex_r_v_rm:
+                               asmvex(ctxt, &p.To, p.From3, &p.From, o.op[z], o.op[z+1])
+                               asmand(ctxt, p, &p.To, &p.From)
+
                        case Zr_m_xm:
                                mediaop(ctxt, o, op, int(yt.zoffset), z)
                                asmand(ctxt, p, &p.To, &p.From)
@@ -4277,7 +4473,8 @@ bad:
                }
        }
 
-       ctxt.Diag("doasm: notfound ft=%d tt=%d %v %d %d", p.Ft, p.Tt, p, oclass(ctxt, p, &p.From), oclass(ctxt, p, &p.To))
+       ctxt.Diag("invalid instruction: %v", p)
+       //      ctxt.Diag("doasm: notfound ft=%d tt=%d %v %d %d", p.Ft, p.Tt, p, oclass(ctxt, p, &p.From), oclass(ctxt, p, &p.To))
        return
 }
 

diff --git a/src/cmd/internal/obj/x86/list6.go b/src/cmd/internal/obj/x86/list6.go
index fc79b902a264deaf5a5e9524337261e2afa4c1f8..0284bbfe8abed8620232fef5b58636e26e6164f6 100644 (file)
--- a/src/cmd/internal/obj/x86/list6.go
+++ b/src/cmd/internal/obj/x86/list6.go
@@ -104,6 +104,22 @@ var Register = []string{
        "X13",
        "X14",
        "X15",
+       "Y0",
+       "Y1",
+       "Y2",
+       "Y3",
+       "Y4",
+       "Y5",
+       "Y6",
+       "Y7",
+       "Y8",
+       "Y9",
+       "Y10",
+       "Y11",
+       "Y12",
+       "Y13",
+       "Y14",
+       "Y15",
        "CS", /* [D_CS] */
        "SS",
        "DS",

diff --git a/src/cmd/internal/obj/x86/obj6_test.go b/src/cmd/internal/obj/x86/obj6_test.go
index d83ab24ab8af22432153d934b191ede1da90202f..a5c80cea3b69db06809c9a2f82b87dbf437ddc04 100644 (file)
--- a/src/cmd/internal/obj/x86/obj6_test.go
+++ b/src/cmd/internal/obj/x86/obj6_test.go
@@ -150,6 +150,13 @@ func parseOutput(t *testing.T, td *ParsedTestData, asmout []byte) {
 func TestDynlink(t *testing.T) {
        testenv.MustHaveGoBuild(t)
 
+       if os.Getenv("GOHOSTARCH") != "" {
+               // TODO: make this work? It was failing due to the
+               // GOARCH= filtering above and skipping is easiest for
+               // now.
+               t.Skip("skipping when GOHOSTARCH is set")
+       }
+
        testdata := parseTestData(t)
        asmout := asmOutput(t, testdata.input)
        parseOutput(t, testdata, asmout)

diff --git a/src/cmd/link/doc.go b/src/cmd/link/doc.go
index 69f9b5785907bd3458dee8e685122bc12f119cfe..ffaead7ba0d31a6f77cce12c2f15b04e5edb3af6 100644 (file)
--- a/src/cmd/link/doc.go
+++ b/src/cmd/link/doc.go
@@ -52,6 +52,9 @@ Flags:
                The dynamic header is on by default, even without any
                references to dynamic libraries, because many common
                system tools now assume the presence of the header.
+       -extar ar
+               Set the external archive program (default "ar").
+               Used only for -buildmode=c-archive.
        -extld linker
                Set the external linker (default "clang" or "gcc").
        -extldflags flags

diff --git a/src/cmd/link/internal/arm/asm.go b/src/cmd/link/internal/arm/asm.go
index 8ffa656208a64755de93e6bdbcd9cfc907d33b7f..74c22497029d4af3c29b7fc86ff9907bbb3c065f 100644 (file)
--- a/src/cmd/link/internal/arm/asm.go
+++ b/src/cmd/link/internal/arm/asm.go
@@ -689,14 +689,14 @@ func asmb() {
        switch ld.HEADTYPE {
        default:
        case obj.Hplan9: /* plan 9 */
-               ld.Thearch.Lput(0x647)                      /* magic */
-               ld.Thearch.Lput(uint32(ld.Segtext.Filelen)) /* sizes */
-               ld.Thearch.Lput(uint32(ld.Segdata.Filelen))
-               ld.Thearch.Lput(uint32(ld.Segdata.Length - ld.Segdata.Filelen))
-               ld.Thearch.Lput(uint32(ld.Symsize))      /* nsyms */
-               ld.Thearch.Lput(uint32(ld.Entryvalue())) /* va of entry */
-               ld.Thearch.Lput(0)
-               ld.Thearch.Lput(uint32(ld.Lcsize))
+               ld.Lputb(0x647)                      /* magic */
+               ld.Lputb(uint32(ld.Segtext.Filelen)) /* sizes */
+               ld.Lputb(uint32(ld.Segdata.Filelen))
+               ld.Lputb(uint32(ld.Segdata.Length - ld.Segdata.Filelen))
+               ld.Lputb(uint32(ld.Symsize))      /* nsyms */
+               ld.Lputb(uint32(ld.Entryvalue())) /* va of entry */
+               ld.Lputb(0)
+               ld.Lputb(uint32(ld.Lcsize))
 
        case obj.Hlinux,
                obj.Hfreebsd,

diff --git a/src/cmd/link/internal/ld/elf.go b/src/cmd/link/internal/ld/elf.go
index a34cf3cac865e72c16cabc2d5ef021ca3f2ab5ac..6d34978d5a0c0b9a790a5a3df3266ed977f44b42 100644 (file)
--- a/src/cmd/link/internal/ld/elf.go
+++ b/src/cmd/link/internal/ld/elf.go
@@ -850,7 +850,26 @@ func Elfinit() {
        }
 }
 
+// Make sure PT_LOAD is aligned properly and
+// that there is no gap,
+// correct ELF loaders will do this implicitly,
+// but buggy ELF loaders like the one in some
+// versions of QEMU and UPX won't.
+func fixElfPhdr(e *ElfPhdr) {
+       frag := int(e.vaddr & (e.align - 1))
+
+       e.off -= uint64(frag)
+       e.vaddr -= uint64(frag)
+       e.paddr -= uint64(frag)
+       e.filesz += uint64(frag)
+       e.memsz += uint64(frag)
+}
+
 func elf64phdr(e *ElfPhdr) {
+       if e.type_ == PT_LOAD {
+               fixElfPhdr(e)
+       }
+
        Thearch.Lput(e.type_)
        Thearch.Lput(e.flags)
        Thearch.Vput(e.off)
@@ -863,16 +882,7 @@ func elf64phdr(e *ElfPhdr) {
 
 func elf32phdr(e *ElfPhdr) {
        if e.type_ == PT_LOAD {
-               // Correct ELF loaders will do this implicitly,
-               // but buggy ELF loaders like the one in some
-               // versions of QEMU won't.
-               frag := int(e.vaddr & (e.align - 1))
-
-               e.off -= uint64(frag)
-               e.vaddr -= uint64(frag)
-               e.paddr -= uint64(frag)
-               e.filesz += uint64(frag)
-               e.memsz += uint64(frag)
+               fixElfPhdr(e)
        }
 
        Thearch.Lput(e.type_)

diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go
index 75612503b1e31126eeab11cc7c12905c4e6f8d5d..bdfa0563c3d269c659ccb628944883c5486361e7 100644 (file)
--- a/src/cmd/link/internal/ld/lib.go
+++ b/src/cmd/link/internal/ld/lib.go
@@ -207,6 +207,7 @@ var (
        tmpdir             string
        extld              string
        extldflags         string
+       extar              string
        libgccfile         string
        debug_s            int // backup old value of debug['s']
        Ctxt               *Link
@@ -504,14 +505,21 @@ func loadlib() {
 
        var i int
        for i = 0; i < len(Ctxt.Library); i++ {
-               if Debug['v'] > 1 {
-                       fmt.Fprintf(&Bso, "%5.2f autolib: %s (from %s)\n", obj.Cputime(), Ctxt.Library[i].File, Ctxt.Library[i].Objref)
-               }
                iscgo = iscgo || Ctxt.Library[i].Pkg == "runtime/cgo"
+               if Ctxt.Library[i].Shlib == "" {
+                       if Debug['v'] > 1 {
+                               fmt.Fprintf(&Bso, "%5.2f autolib: %s (from %s)\n", obj.Cputime(), Ctxt.Library[i].File, Ctxt.Library[i].Objref)
+                       }
+                       objfile(Ctxt.Library[i])
+               }
+       }
+
+       for i = 0; i < len(Ctxt.Library); i++ {
                if Ctxt.Library[i].Shlib != "" {
+                       if Debug['v'] > 1 {
+                               fmt.Fprintf(&Bso, "%5.2f autolib: %s (from %s)\n", obj.Cputime(), Ctxt.Library[i].Shlib, Ctxt.Library[i].Objref)
+                       }
                        ldshlibsyms(Ctxt.Library[i].Shlib)
-               } else {
-                       objfile(Ctxt.Library[i])
                }
        }
 
@@ -1008,8 +1016,12 @@ func archive() {
                return
        }
 
+       if extar == "" {
+               extar = "ar"
+       }
+
        mayberemoveoutfile()
-       argv := []string{"ar", "-q", "-c", "-s", outfile}
+       argv := []string{extar, "-q", "-c", "-s", outfile}
        argv = append(argv, fmt.Sprintf("%s/go.o", tmpdir))
        argv = append(argv, hostobjCopy()...)
 
@@ -1458,18 +1470,11 @@ func ldshlibsyms(shlib string) {
                        continue
                }
                lsym := Linklookup(Ctxt, elfsym.Name, 0)
-               if lsym.Type != 0 && lsym.Type != obj.SDYNIMPORT && lsym.Dupok == 0 {
-                       if (lsym.Type != obj.SBSS && lsym.Type != obj.SNOPTRBSS) || len(lsym.R) != 0 || len(lsym.P) != 0 || f.Sections[elfsym.Section].Type != elf.SHT_NOBITS {
-                               Diag("Found duplicate symbol %s reading from %s, first found in %s", elfsym.Name, shlib, lsym.File)
-                       }
-                       if lsym.Size > int64(elfsym.Size) {
-                               // If the existing symbol is a BSS value that is
-                               // larger than the one read from the shared library,
-                               // keep references to that.  Conversely, if the
-                               // version from the shared libray is larger, we want
-                               // to make all references be to that.
-                               continue
-                       }
+               // Because loadlib above loads all .a files before loading any shared
+               // libraries, any symbols we find that duplicate symbols already
+               // loaded should be ignored (the symbols from the .a files "win").
+               if lsym.Type != 0 {
+                       continue
                }
                lsym.Type = obj.SDYNIMPORT
                lsym.ElfType = elf.ST_TYPE(elfsym.Info)

diff --git a/src/cmd/link/internal/ld/pobj.go b/src/cmd/link/internal/ld/pobj.go
index 319e85046706858b3b3b73aa8e7b138a4ac2c2b1..808d377f8a0473ea1744658e9a49027219d30725 100644 (file)
--- a/src/cmd/link/internal/ld/pobj.go
+++ b/src/cmd/link/internal/ld/pobj.go
@@ -89,6 +89,7 @@ func Ldmain() {
        flag.Var(&Buildmode, "buildmode", "set build `mode`")
        obj.Flagcount("c", "dump call graph", &Debug['c'])
        obj.Flagcount("d", "disable dynamic executable", &Debug['d'])
+       obj.Flagstr("extar", "archive program for buildmode=c-archive", &extar)
        obj.Flagstr("extld", "use `linker` when linking in external mode", &extld)
        obj.Flagstr("extldflags", "pass `flags` to external linker", &extldflags)
        obj.Flagcount("f", "ignore version mismatch", &Debug['f'])

diff --git a/src/cmd/vet/cgo.go b/src/cmd/vet/cgo.go
index 8807952b48ab867767e506400b196ab4a90a8cd8..1985a86fe0100146138a674e53620e8dbf4b7a1a 100644 (file)
--- a/src/cmd/vet/cgo.go
+++ b/src/cmd/vet/cgo.go
@@ -72,6 +72,9 @@ func cgoBaseType(f *File, arg ast.Expr) types.Type {
                }
                // Here arg is *f(v).
                t := f.pkg.types[call.Fun].Type
+               if t == nil {
+                       break
+               }
                ptr, ok := t.Underlying().(*types.Pointer)
                if !ok {
                        break

diff --git a/src/cmd/vet/print.go b/src/cmd/vet/print.go
index 5436c5bf04b5b486a2e94322ea25201c713158c6..a16e864cad212df7fc5480b736037c6d448e7fda 100644 (file)
--- a/src/cmd/vet/print.go
+++ b/src/cmd/vet/print.go
@@ -445,12 +445,12 @@ func (f *File) okPrintfArg(call *ast.CallExpr, state *formatState) (ok bool) {
                return false
        }
        arg := call.Args[argNum]
+       if f.isFunctionValue(arg) && state.verb != 'p' && state.verb != 'T' {
+               f.Badf(call.Pos(), "arg %s in printf call is a function value, not a function call", f.gofmt(arg))
+               return false
+       }
        if !f.matchArgType(v.typ, nil, arg) {
                typeString := ""
-               if f.isFunctionValue(arg) {
-                       f.Badf(call.Pos(), "arg %s in printf call is a function value, not a function call", f.gofmt(arg))
-                       return false
-               }
                if typ := f.pkg.types[arg].Type; typ != nil {
                        typeString = typ.String()
                }

diff --git a/src/cmd/vet/testdata/cgo2.go b/src/cmd/vet/testdata/cgo2.go
new file mode 100644 (file)
index 0000000..276aea9
--- /dev/null
+++ b/src/cmd/vet/testdata/cgo2.go
@@ -0,0 +1,9 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Test the cgo checker on a file that doesn't use cgo.
+
+package testdata
+
+var _ = C.f(*p(**p))

diff --git a/src/cmd/vet/testdata/print.go b/src/cmd/vet/testdata/print.go
index beeb642f2ad19dbf07c6f393d4bc922501df1b60..c5faa36e897a957d57e237b4fea8113ecdc89382 100644 (file)
--- a/src/cmd/vet/testdata/print.go
+++ b/src/cmd/vet/testdata/print.go
@@ -197,7 +197,10 @@ func PrintfTests() {
        et5.error() // ok, not an error method.
        // Can't print a function.
        Printf("%d", someFunction) // ERROR "arg someFunction in printf call is a function value, not a function call"
+       Printf("%v", someFunction) // ERROR "arg someFunction in printf call is a function value, not a function call"
        Println(someFunction)      // ERROR "arg someFunction in Println call is a function value, not a function call"
+       Printf("%p", someFunction) // ok: maybe someone wants to see the pointer
+       Printf("%T", someFunction) // ok: maybe someone wants to see the type
        // Bug: used to recur forever.
        Printf("%p %x", recursiveStructV, recursiveStructV.next)
        Printf("%p %x", recursiveStruct1V, recursiveStruct1V.next)

diff --git a/src/crypto/cipher/example_test.go b/src/crypto/cipher/example_test.go
index 1cfa982df4ba4d7de1fa2db172078002ed64a6dc..f6cc38650610ad23fa474df2a913eabbb5ef106e 100644 (file)
--- a/src/crypto/cipher/example_test.go
+++ b/src/crypto/cipher/example_test.go
@@ -14,6 +14,58 @@ import (
        "os"
 )
 
+func ExampleNewGCMEncrypter() {
+       // The key argument should be the AES key, either 16 or 32 bytes
+       // to select AES-128 or AES-256.
+       key := []byte("AES256Key-32Characters1234567890")
+       plaintext := []byte("exampleplaintext")
+
+       block, err := aes.NewCipher(key)
+       if err != nil {
+               panic(err.Error())
+       }
+
+       // Never use more than 2^32 random nonces with a given key because of the risk of a repeat.
+       nonce := make([]byte, 12)
+       if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
+               panic(err.Error())
+       }
+
+       aesgcm, err := cipher.NewGCM(block)
+       if err != nil {
+               panic(err.Error())
+       }
+
+       ciphertext := aesgcm.Seal(nil, nonce, plaintext, nil)
+       fmt.Printf("%x\n", ciphertext)
+}
+
+func ExampleNewGCMDecrypter() {
+       // The key argument should be the AES key, either 16 or 32 bytes
+       // to select AES-128 or AES-256.
+       key := []byte("AES256Key-32Characters1234567890")
+       ciphertext, _ := hex.DecodeString("f90fbef747e7212ad7410d0eee2d965de7e890471695cddd2a5bc0ef5da1d04ad8147b62141ad6e4914aee8c512f64fba9037603d41de0d50b718bd665f019cdcd")
+
+       nonce, _ := hex.DecodeString("bb8ef84243d2ee95a41c6c57")
+
+       block, err := aes.NewCipher(key)
+       if err != nil {
+               panic(err.Error())
+       }
+
+       aesgcm, err := cipher.NewGCM(block)
+       if err != nil {
+               panic(err.Error())
+       }
+
+       plaintext, err := aesgcm.Open(nil, nonce, ciphertext, nil)
+       if err != nil {
+               panic(err.Error())
+       }
+
+       fmt.Printf("%s\n", string(plaintext))
+}
+
 func ExampleNewCBCDecrypter() {
        key := []byte("example key 1234")
        ciphertext, _ := hex.DecodeString("f363f3ccdcb12bb883abf484ba77d9cd7d32b5baecb3d4b1b3e0e4beffdb3ded")

diff --git a/src/crypto/crypto.go b/src/crypto/crypto.go
index 184ea9d4d62c74ae04419ca5cf8edb1f7f883d17..a80ebd36931eac75c9a841bd207edbf2b379df46 100644 (file)
--- a/src/crypto/crypto.go
+++ b/src/crypto/crypto.go
@@ -109,7 +109,7 @@ type Signer interface {
        // private key.
        Public() PublicKey
 
-       // Sign signs msg with the private key, possibly using entropy from
+       // Sign signs digest with the private key, possibly using entropy from
        // rand. For an RSA key, the resulting signature should be either a
        // PKCS#1 v1.5 or PSS signature (as indicated by opts). For an (EC)DSA
        // key, it should be a DER-serialised, ASN.1 signature structure.
@@ -118,7 +118,11 @@ type Signer interface {
        // simply pass in the hash function used as opts. Sign may also attempt
        // to type assert opts to other types in order to obtain algorithm
        // specific values. See the documentation in each package for details.
-       Sign(rand io.Reader, msg []byte, opts SignerOpts) (signature []byte, err error)
+       //
+       // Note that when a signature of a hash of a larger message is needed,
+       // the caller is responsible for hashing the larger message and passing
+       // the hash (as digest) and the hash function (as opts) to Sign.
+       Sign(rand io.Reader, digest []byte, opts SignerOpts) (signature []byte, err error)
 }
 
 // SignerOpts contains options for signing with a Signer.

diff --git a/src/crypto/rsa/example_test.go b/src/crypto/rsa/example_test.go
new file mode 100644 (file)
index 0000000..1435b70
--- /dev/null
+++ b/src/crypto/rsa/example_test.go
@@ -0,0 +1,169 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package rsa
+
+import (
+       "crypto"
+       "crypto/aes"
+       "crypto/cipher"
+       "crypto/rand"
+       "crypto/sha256"
+       "encoding/hex"
+       "fmt"
+       "io"
+       "os"
+)
+
+// RSA is able to encrypt only a very limited amount of data. In order
+// to encrypt reasonable amounts of data a hybrid scheme is commonly
+// used: RSA is used to encrypt a key for a symmetric primitive like
+// AES-GCM.
+//
+// Before encrypting, data is “padded” by embedding it in a known
+// structure. This is done for a number of reasons, but the most
+// obvious is to ensure that the value is large enough that the
+// exponentiation is larger than the modulus. (Otherwise it could be
+// decrypted with a square-root.)
+//
+// In these designs, when using PKCS#1 v1.5, it's vitally important to
+// avoid disclosing whether the received RSA message was well-formed
+// (that is, whether the result of decrypting is a correctly padded
+// message) because this leaks secret information.
+// DecryptPKCS1v15SessionKey is designed for this situation and copies
+// the decrypted, symmetric key (if well-formed) in constant-time over
+// a buffer that contains a random key. Thus, if the RSA result isn't
+// well-formed, the implementation uses a random key in constant time.
+func ExampleDecryptPKCS1v15SessionKey() {
+       // crypto/rand.Reader is a good source of entropy for blinding the RSA
+       // operation.
+       rng := rand.Reader
+
+       // The hybrid scheme should use at least a 16-byte symmetric key. Here
+       // we read the random key that will be used if the RSA decryption isn't
+       // well-formed.
+       key := make([]byte, 32)
+       if _, err := io.ReadFull(rng, key); err != nil {
+               panic("RNG failure")
+       }
+
+       rsaCiphertext, _ := hex.DecodeString("aabbccddeeff")
+
+       if err := DecryptPKCS1v15SessionKey(rng, rsaPrivateKey, rsaCiphertext, key); err != nil {
+               // Any errors that result will be “public” – meaning that they
+               // can be determined without any secret information. (For
+               // instance, if the length of key is impossible given the RSA
+               // public key.)
+               fmt.Fprintf(os.Stderr, "Error from RSA decryption: %s\n", err)
+               return
+       }
+
+       // Given the resulting key, a symmetric scheme can be used to decrypt a
+       // larger ciphertext.
+       block, err := aes.NewCipher(key)
+       if err != nil {
+               panic("aes.NewCipher failed: " + err.Error())
+       }
+
+       // Since the key is random, using a fixed nonce is acceptable as the
+       // (key, nonce) pair will still be unique, as required.
+       var zeroNonce [12]byte
+       aead, err := cipher.NewGCM(block)
+       if err != nil {
+               panic("cipher.NewGCM failed: " + err.Error())
+       }
+       ciphertext, _ := hex.DecodeString("00112233445566")
+       plaintext, err := aead.Open(nil, zeroNonce[:], ciphertext, nil)
+       if err != nil {
+               // The RSA ciphertext was badly formed; the decryption will
+               // fail here because the AES-GCM key will be incorrect.
+               fmt.Fprintf(os.Stderr, "Error decrypting: %s\n", err)
+               return
+       }
+
+       fmt.Printf("Plaintext: %s\n", string(plaintext))
+}
+
+func ExampleSignPKCS1v15() {
+       // crypto/rand.Reader is a good source of entropy for blinding the RSA
+       // operation.
+       rng := rand.Reader
+
+       message := []byte("message to be signed")
+
+       // Only small messages can be signed directly; thus the hash of a
+       // message, rather than the message itself, is signed. This requires
+       // that the hash function be collision resistant. SHA-256 is the
+       // least-strong hash function that should be used for this at the time
+       // of writing (2016).
+       hashed := sha256.Sum256(message)
+
+       signature, err := SignPKCS1v15(rng, rsaPrivateKey, crypto.SHA256, hashed[:])
+       if err != nil {
+               fmt.Fprintf(os.Stderr, "Error from signing: %s\n", err)
+               return
+       }
+
+       fmt.Printf("Signature: %x\n", signature)
+}
+
+func ExampleVerifyPKCS1v15() {
+       message := []byte("message to be signed")
+       signature, _ := hex.DecodeString("ad2766728615cc7a746cc553916380ca7bfa4f8983b990913bc69eb0556539a350ff0f8fe65ddfd3ebe91fe1c299c2fac135bc8c61e26be44ee259f2f80c1530")
+
+       // Only small messages can be signed directly; thus the hash of a
+       // message, rather than the message itself, is signed. This requires
+       // that the hash function be collision resistant. SHA-256 is the
+       // least-strong hash function that should be used for this at the time
+       // of writing (2016).
+       hashed := sha256.Sum256(message)
+
+       err := VerifyPKCS1v15(&rsaPrivateKey.PublicKey, crypto.SHA256, hashed[:], signature)
+       if err != nil {
+               fmt.Fprintf(os.Stderr, "Error from verification: %s\n", err)
+               return
+       }
+
+       // signature is a valid signature of message from the public key.
+}
+
+func ExampleEncryptOAEP() {
+       secretMessage := []byte("send reinforcements, we're going to advance")
+       label := []byte("orders")
+
+       // crypto/rand.Reader is a good source of entropy for randomizing the
+       // encryption function.
+       rng := rand.Reader
+
+       ciphertext, err := EncryptOAEP(sha256.New(), rng, &test2048Key.PublicKey, secretMessage, label)
+       if err != nil {
+               fmt.Fprintf(os.Stderr, "Error from encryption: %s\n", err)
+               return
+       }
+
+       // Since encryption is a randomized function, ciphertext will be
+       // different each time.
+       fmt.Printf("Ciphertext: %x\n", ciphertext)
+}
+
+func ExampleDecryptOAEP() {
+       ciphertext, _ := hex.DecodeString("4d1ee10e8f286390258c51a5e80802844c3e6358ad6690b7285218a7c7ed7fc3a4c7b950fbd04d4b0239cc060dcc7065ca6f84c1756deb71ca5685cadbb82be025e16449b905c568a19c088a1abfad54bf7ecc67a7df39943ec511091a34c0f2348d04e058fcff4d55644de3cd1d580791d4524b92f3e91695582e6e340a1c50b6c6d78e80b4e42c5b4d45e479b492de42bbd39cc642ebb80226bb5200020d501b24a37bcc2ec7f34e596b4fd6b063de4858dbf5a4e3dd18e262eda0ec2d19dbd8e890d672b63d368768360b20c0b6b8592a438fa275e5fa7f60bef0dd39673fd3989cc54d2cb80c08fcd19dacbc265ee1c6014616b0e04ea0328c2a04e73460")
+       label := []byte("orders")
+
+       // crypto/rand.Reader is a good source of entropy for blinding the RSA
+       // operation.
+       rng := rand.Reader
+
+       plaintext, err := DecryptOAEP(sha256.New(), rng, test2048Key, ciphertext, label)
+       if err != nil {
+               fmt.Fprintf(os.Stderr, "Error from decryption: %s\n", err)
+               return
+       }
+
+       fmt.Printf("Plaintext: %s\n", string(plaintext))
+
+       // Remember that encryption only provides confidentiality. The
+       // ciphertext should be signed before authenticity is assumed and, even
+       // then, consider that messages might be reordered.
+}

diff --git a/src/crypto/rsa/pkcs1v15.go b/src/crypto/rsa/pkcs1v15.go
index 37eaf1ab3e728911a62e6a2d7e4965c445b9210a..5c5f415c88dee0314d5a4ebb2939644f2d743594 100644 (file)
--- a/src/crypto/rsa/pkcs1v15.go
+++ b/src/crypto/rsa/pkcs1v15.go
@@ -26,6 +26,10 @@ type PKCS1v15DecryptOptions struct {
 
 // EncryptPKCS1v15 encrypts the given message with RSA and the padding scheme from PKCS#1 v1.5.
 // The message must be no longer than the length of the public modulus minus 11 bytes.
+//
+// The rand parameter is used as a source of entropy to ensure that encrypting
+// the same message twice doesn't result in the same ciphertext.
+//
 // WARNING: use of this function to encrypt plaintexts other than session keys
 // is dangerous. Use RSA OAEP in new protocols.
 func EncryptPKCS1v15(rand io.Reader, pub *PublicKey, msg []byte) (out []byte, err error) {
@@ -59,6 +63,12 @@ func EncryptPKCS1v15(rand io.Reader, pub *PublicKey, msg []byte) (out []byte, er
 
 // DecryptPKCS1v15 decrypts a plaintext using RSA and the padding scheme from PKCS#1 v1.5.
 // If rand != nil, it uses RSA blinding to avoid timing side-channel attacks.
+//
+// Note that whether this function returns an error or not discloses secret
+// information. If an attacker can cause this function to run repeatedly and
+// learn whether each instance returned an error then they can decrypt and
+// forge signatures as if they had the private key. See
+// DecryptPKCS1v15SessionKey for a way of solving this problem.
 func DecryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (out []byte, err error) {
        if err := checkPub(&priv.PublicKey); err != nil {
                return nil, err
@@ -87,6 +97,12 @@ func DecryptPKCS1v15(rand io.Reader, priv *PrivateKey, ciphertext []byte) (out [
 // See ``Chosen Ciphertext Attacks Against Protocols Based on the RSA
 // Encryption Standard PKCS #1'', Daniel Bleichenbacher, Advances in Cryptology
 // (Crypto '98).
+//
+// Note that if the session key is too small then it may be possible for an
+// attacker to brute-force it. If they can do that then they can learn whether
+// a random value was used (because it'll be different for the same ciphertext)
+// and thus whether the padding was correct. This defeats the point of this
+// function. Using at least a 16-byte key will protect against this attack.
 func DecryptPKCS1v15SessionKey(rand io.Reader, priv *PrivateKey, ciphertext []byte, key []byte) (err error) {
        if err := checkPub(&priv.PublicKey); err != nil {
                return err
@@ -201,6 +217,13 @@ var hashPrefixes = map[crypto.Hash][]byte{
 // Note that hashed must be the result of hashing the input message using the
 // given hash function. If hash is zero, hashed is signed directly. This isn't
 // advisable except for interoperability.
+//
+// If rand is not nil then RSA blinding will be used to avoid timing side-channel attacks.
+//
+// This function is deterministic. Thus, if the set of possible messages is
+// small, an attacker may be able to build a map from messages to signatures
+// and identify the signed messages. As ever, signatures provide authenticity,
+// not confidentiality.
 func SignPKCS1v15(rand io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte) (s []byte, err error) {
        hashLen, prefix, err := pkcs1v15HashInfo(hash, len(hashed))
        if err != nil {

diff --git a/src/crypto/rsa/rsa.go b/src/crypto/rsa/rsa.go
index 0a3e6acee96cb4d1cf6aae55aedc94158d743837..ee022b803ae21fffd6d67ed2922a883c6d56dcbf 100644 (file)
--- a/src/crypto/rsa/rsa.go
+++ b/src/crypto/rsa/rsa.go
@@ -3,6 +3,21 @@
 // license that can be found in the LICENSE file.
 
 // Package rsa implements RSA encryption as specified in PKCS#1.
+//
+// RSA is a single, fundamental operation that is used in this package to
+// implement either public-key encryption or public-key signatures.
+//
+// The original specification for encryption and signatures with RSA is PKCS#1
+// and the terms "RSA encryption" and "RSA signatures" by default refer to
+// PKCS#1 version 1.5. However, that specification has flaws and new designs
+// should use version two, usually called by just OAEP and PSS, where
+// possible.
+//
+// Two sets of interfaces are included in this package. When a more abstract
+// interface isn't neccessary, there are functions for encrypting/decrypting
+// with v1.5/OAEP and signing/verifying with v1.5/PSS. If one needs to abstract
+// over the public-key primitive, the PrivateKey struct implements the
+// Decrypter and Signer interfaces from the crypto package.
 package rsa
 
 import (
@@ -317,6 +332,20 @@ func encrypt(c *big.Int, pub *PublicKey, m *big.Int) *big.Int {
 }
 
 // EncryptOAEP encrypts the given message with RSA-OAEP.
+//
+// OAEP is parameterised by a hash function that is used as a random oracle.
+// Encryption and decryption of a given message must use the same hash function
+// and sha256.New() is a reasonable choice.
+//
+// The random parameter is used as a source of entropy to ensure that
+// encrypting the same message twice doesn't result in the same ciphertext.
+//
+// The label parameter may contain arbitrary data that will not be encrypted,
+// but which gives important context to the message. For example, if a given
+// public key is used to decrypt two types of messages then distinct label
+// values could be used to ensure that a ciphertext for one purpose cannot be
+// used for another by an attacker. If not required it can be empty.
+//
 // The message must be no longer than the length of the public modulus less
 // twice the hash length plus 2.
 func EncryptOAEP(hash hash.Hash, random io.Reader, pub *PublicKey, msg []byte, label []byte) (out []byte, err error) {
@@ -522,7 +551,17 @@ func decryptAndCheck(random io.Reader, priv *PrivateKey, c *big.Int) (m *big.Int
 }
 
 // DecryptOAEP decrypts ciphertext using RSA-OAEP.
-// If random != nil, DecryptOAEP uses RSA blinding to avoid timing side-channel attacks.
+
+// OAEP is parameterised by a hash function that is used as a random oracle.
+// Encryption and decryption of a given message must use the same hash function
+// and sha256.New() is a reasonable choice.
+//
+// The random parameter, if not nil, is used to blind the private-key operation
+// and avoid timing side-channel attacks. Blinding is purely internal to this
+// function – the random data need not match that used when encrypting.
+//
+// The label parameter must match the value given when encrypting. See
+// EncryptOAEP for details.
 func DecryptOAEP(hash hash.Hash, random io.Reader, priv *PrivateKey, ciphertext []byte, label []byte) (msg []byte, err error) {
        if err := checkPub(&priv.PublicKey); err != nil {
                return nil, err

diff --git a/src/crypto/tls/tls.go b/src/crypto/tls/tls.go
index c1d1331bde2e0a3d047bef77c1c07303bc81a29d..4bedd7682d3600ddaf04e3a8ded5de9af113fab0 100644 (file)
--- a/src/crypto/tls/tls.go
+++ b/src/crypto/tls/tls.go
@@ -172,7 +172,9 @@ func Dial(network, addr string, config *Config) (*Conn, error) {
 }
 
 // LoadX509KeyPair reads and parses a public/private key pair from a pair of
-// files. The files must contain PEM encoded data.
+// files. The files must contain PEM encoded data. On successful return,
+// Certificate.Leaf will be nil because the parsed form of the certificate is
+// not retained.
 func LoadX509KeyPair(certFile, keyFile string) (Certificate, error) {
        certPEMBlock, err := ioutil.ReadFile(certFile)
        if err != nil {
@@ -186,7 +188,8 @@ func LoadX509KeyPair(certFile, keyFile string) (Certificate, error) {
 }
 
 // X509KeyPair parses a public/private key pair from a pair of
-// PEM encoded data.
+// PEM encoded data. On successful return, Certificate.Leaf will be nil because
+// the parsed form of the certificate is not retained.
 func X509KeyPair(certPEMBlock, keyPEMBlock []byte) (Certificate, error) {
        fail := func(err error) (Certificate, error) { return Certificate{}, err }
 

diff --git a/src/database/sql/convert.go b/src/database/sql/convert.go
index bba5a8843a0fcf9b2e6b3fc69589c58499bcedc4..740fd9d6e7c9af2a82a0f0d297e53b70d92e2d2e 100644 (file)
--- a/src/database/sql/convert.go
+++ b/src/database/sql/convert.go
@@ -12,6 +12,7 @@ import (
        "fmt"
        "reflect"
        "strconv"
+       "time"
 )
 
 var errNilPtr = errors.New("destination pointer is nil") // embedded in descriptive error
@@ -127,6 +128,18 @@ func convertAssign(dest, src interface{}) error {
                        *d = s
                        return nil
                }
+       case time.Time:
+               switch d := dest.(type) {
+               case *string:
+                       *d = s.Format(time.RFC3339Nano)
+                       return nil
+               case *[]byte:
+                       if d == nil {
+                               return errNilPtr
+                       }
+                       *d = []byte(s.Format(time.RFC3339Nano))
+                       return nil
+               }
        case nil:
                switch d := dest.(type) {
                case *interface{}:
@@ -226,7 +239,8 @@ func convertAssign(dest, src interface{}) error {
                s := asString(src)
                i64, err := strconv.ParseInt(s, 10, dv.Type().Bits())
                if err != nil {
-                       return fmt.Errorf("converting string %q to a %s: %v", s, dv.Kind(), err)
+                       err = strconvErr(err)
+                       return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
                }
                dv.SetInt(i64)
                return nil
@@ -234,7 +248,8 @@ func convertAssign(dest, src interface{}) error {
                s := asString(src)
                u64, err := strconv.ParseUint(s, 10, dv.Type().Bits())
                if err != nil {
-                       return fmt.Errorf("converting string %q to a %s: %v", s, dv.Kind(), err)
+                       err = strconvErr(err)
+                       return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
                }
                dv.SetUint(u64)
                return nil
@@ -242,13 +257,21 @@ func convertAssign(dest, src interface{}) error {
                s := asString(src)
                f64, err := strconv.ParseFloat(s, dv.Type().Bits())
                if err != nil {
-                       return fmt.Errorf("converting string %q to a %s: %v", s, dv.Kind(), err)
+                       err = strconvErr(err)
+                       return fmt.Errorf("converting driver.Value type %T (%q) to a %s: %v", src, s, dv.Kind(), err)
                }
                dv.SetFloat(f64)
                return nil
        }
 
-       return fmt.Errorf("unsupported driver -> Scan pair: %T -> %T", src, dest)
+       return fmt.Errorf("unsupported Scan, storing driver.Value type %T into type %T", src, dest)
+}
+
+func strconvErr(err error) error {
+       if ne, ok := err.(*strconv.NumError); ok {
+               return ne.Err
+       }
+       return err
 }
 
 func cloneBytes(b []byte) []byte {

diff --git a/src/database/sql/convert_test.go b/src/database/sql/convert_test.go
index 1fab282b40896ab816d1ceb12a9b855d6a887a9b..342875e190c99ed12baf1e14d720e8b512e9526b 100644 (file)
--- a/src/database/sql/convert_test.go
+++ b/src/database/sql/convert_test.go
@@ -77,6 +77,14 @@ var conversionTests = []conversionTest{
        {s: uint64(123), d: &scanstr, wantstr: "123"},
        {s: 1.5, d: &scanstr, wantstr: "1.5"},
 
+       // From time.Time:
+       {s: time.Unix(1, 0).UTC(), d: &scanstr, wantstr: "1970-01-01T00:00:01Z"},
+       {s: time.Unix(1453874597, 0).In(time.FixedZone("here", -3600*8)), d: &scanstr, wantstr: "2016-01-26T22:03:17-08:00"},
+       {s: time.Unix(1, 2).UTC(), d: &scanstr, wantstr: "1970-01-01T00:00:01.000000002Z"},
+       {s: time.Time{}, d: &scanstr, wantstr: "0001-01-01T00:00:00Z"},
+       {s: time.Unix(1, 2).UTC(), d: &scanbytes, wantbytes: []byte("1970-01-01T00:00:01.000000002Z")},
+       {s: time.Unix(1, 2).UTC(), d: &scaniface, wantiface: time.Unix(1, 2).UTC()},
+
        // To []byte
        {s: nil, d: &scanbytes, wantbytes: nil},
        {s: "string", d: &scanbytes, wantbytes: []byte("string")},
@@ -104,10 +112,16 @@ var conversionTests = []conversionTest{
 
        // Strings to integers
        {s: "255", d: &scanuint8, wantuint: 255},
-       {s: "256", d: &scanuint8, wanterr: `converting string "256" to a uint8: strconv.ParseUint: parsing "256": value out of range`},
+       {s: "256", d: &scanuint8, wanterr: "converting driver.Value type string (\"256\") to a uint8: value out of range"},
        {s: "256", d: &scanuint16, wantuint: 256},
        {s: "-1", d: &scanint, wantint: -1},
-       {s: "foo", d: &scanint, wanterr: `converting string "foo" to a int: strconv.ParseInt: parsing "foo": invalid syntax`},
+       {s: "foo", d: &scanint, wanterr: "converting driver.Value type string (\"foo\") to a int: invalid syntax"},
+
+       // int64 to smaller integers
+       {s: int64(5), d: &scanuint8, wantuint: 5},
+       {s: int64(256), d: &scanuint8, wanterr: "converting driver.Value type int64 (\"256\") to a uint8: value out of range"},
+       {s: int64(256), d: &scanuint16, wantuint: 256},
+       {s: int64(65536), d: &scanuint16, wanterr: "converting driver.Value type int64 (\"65536\") to a uint16: value out of range"},
 
        // True bools
        {s: true, d: &scanbool, wantbool: true},
@@ -155,7 +169,10 @@ var conversionTests = []conversionTest{
        {s: 1.5, d: new(userDefined), wantusrdef: 1.5},
        {s: int64(123), d: new(userDefined), wantusrdef: 123},
        {s: "1.5", d: new(userDefined), wantusrdef: 1.5},
-       {s: []byte{1, 2, 3}, d: new(userDefinedSlice), wanterr: `unsupported driver -> Scan pair: []uint8 -> *sql.userDefinedSlice`},
+       {s: []byte{1, 2, 3}, d: new(userDefinedSlice), wanterr: `unsupported Scan, storing driver.Value type []uint8 into type *sql.userDefinedSlice`},
+
+       // Other errors
+       {s: complex(1, 2), d: &scanstr, wanterr: `unsupported Scan, storing driver.Value type complex128 into type *string`},
 }
 
 func intPtrValue(intptr interface{}) interface{} {

diff --git a/src/database/sql/sql.go b/src/database/sql/sql.go
index b5a17f0fc1ac359146c1466851acccb12e725aa2..d8e7cb77af396e0d735ee766410adb91591b887c 100644 (file)
--- a/src/database/sql/sql.go
+++ b/src/database/sql/sql.go
@@ -189,8 +189,7 @@ func (n NullBool) Value() (driver.Value, error) {
 type Scanner interface {
        // Scan assigns a value from a database driver.
        //
-       // The src value will be of one of the following restricted
-       // set of types:
+       // The src value will be of one of the following types:
        //
        //    int64
        //    float64
@@ -1786,17 +1785,56 @@ func (rs *Rows) Columns() ([]string, error) {
 }
 
 // Scan copies the columns in the current row into the values pointed
-// at by dest.
+// at by dest. The number of values in dest must be the same as the
+// number of columns in Rows.
 //
-// If an argument has type *[]byte, Scan saves in that argument a copy
-// of the corresponding data. The copy is owned by the caller and can
-// be modified and held indefinitely. The copy can be avoided by using
-// an argument of type *RawBytes instead; see the documentation for
-// RawBytes for restrictions on its use.
+// Scan converts columns read from the database into the following
+// common Go types and special types provided by the sql package:
+//
+//    *string
+//    *[]byte
+//    *int, *int8, *int16, *int32, *int64
+//    *uint, *uint8, *uint16, *uint32, *uint64
+//    *bool
+//    *float32, *float64
+//    *interface{}
+//    *RawBytes
+//    any type implementing Scanner (see Scanner docs)
+//
+// In the most simple case, if the type of the value from the source
+// column is an integer, bool or string type T and dest is of type *T,
+// Scan simply assigns the value through the pointer.
+//
+// Scan also converts between string and numeric types, as long as no
+// information would be lost. While Scan stringifies all numbers
+// scanned from numeric database columns into *string, scans into
+// numeric types are checked for overflow. For example, a float64 with
+// value 300 or a string with value "300" can scan into a uint16, but
+// not into a uint8, though float64(255) or "255" can scan into a
+// uint8. One exception is that scans of some float64 numbers to
+// strings may lose information when stringifying. In general, scan
+// floating point columns into *float64.
+//
+// If a dest argument has type *[]byte, Scan saves in that argument a
+// copy of the corresponding data. The copy is owned by the caller and
+// can be modified and held indefinitely. The copy can be avoided by
+// using an argument of type *RawBytes instead; see the documentation
+// for RawBytes for restrictions on its use.
 //
 // If an argument has type *interface{}, Scan copies the value
-// provided by the underlying driver without conversion. If the value
-// is of type []byte, a copy is made and the caller owns the result.
+// provided by the underlying driver without conversion. When scanning
+// from a source value of type []byte to *interface{}, a copy of the
+// slice is made and the caller owns the result.
+//
+// Source values of type time.Time may be scanned into values of type
+// *time.Time, *interface{}, *string, or *[]byte. When converting to
+// the latter two, time.Format3339Nano is used.
+//
+// Source values of type bool may be scanned into types *bool,
+// *interface{}, *string, *[]byte, or *RawBytes.
+//
+// For scanning into *bool, the source may be true, false, 1, 0, or
+// string inputs parseable by strconv.ParseBool.
 func (rs *Rows) Scan(dest ...interface{}) error {
        if rs.closed {
                return errors.New("sql: Rows are closed")
@@ -1845,8 +1883,9 @@ type Row struct {
 }
 
 // Scan copies the columns from the matched row into the values
-// pointed at by dest.  If more than one row matches the query,
-// Scan uses the first row and discards the rest.  If no row matches
+// pointed at by dest. See the documentation on Rows.Scan for details.
+// If more than one row matches the query,
+// Scan uses the first row and discards the rest. If no row matches
 // the query, Scan returns ErrNoRows.
 func (r *Row) Scan(dest ...interface{}) error {
        if r.err != nil {

diff --git a/src/encoding/xml/xml.go b/src/encoding/xml/xml.go
index 70ff8771720634244557c9c2adc17f009278d449..45f4157318a49ac59751655751160d848a91f0a9 100644 (file)
--- a/src/encoding/xml/xml.go
+++ b/src/encoding/xml/xml.go
@@ -227,7 +227,8 @@ func NewDecoder(r io.Reader) *Decoder {
 //
 // Token guarantees that the StartElement and EndElement
 // tokens it returns are properly nested and matched:
-// if Token encounters an unexpected end element,
+// if Token encounters an unexpected end element
+// or EOF before all expected end elements,
 // it will return an error.
 //
 // Token implements XML name spaces as described by

diff --git a/src/go/build/build_test.go b/src/go/build/build_test.go
index 61aac8fe5f292dd905614f79117043490a69fd2a..7312af08b57b14752dea88862d476dafa46041f7 100644 (file)
--- a/src/go/build/build_test.go
+++ b/src/go/build/build_test.go
@@ -300,6 +300,7 @@ func TestShellSafety(t *testing.T) {
 }
 
 func TestImportVendor(t *testing.T) {
+       t.Skip("skipping; hpack has moved to internal for now; golang.org/issue/14047")
        testenv.MustHaveGoBuild(t) // really must just have source
        ctxt := Default
        ctxt.GOPATH = ""

diff --git a/src/go/build/deps_test.go b/src/go/build/deps_test.go
index 4603102526ffa3ded9f52c23e5fe5e42b8674f73..376931e1981e034961bb01e53ef12d10813635d9 100644 (file)
--- a/src/go/build/deps_test.go
+++ b/src/go/build/deps_test.go
@@ -358,7 +358,7 @@ var pkgDeps = map[string][]string{
                "L4", "NET", "OS",
                "compress/gzip", "crypto/tls", "mime/multipart", "runtime/debug",
                "net/http/internal",
-               "golang.org/x/net/http2/hpack",
+               "internal/golang.org/x/net/http2/hpack",
        },
        "net/http/internal": {"L4"},
 

diff --git a/src/go/constant/value.go b/src/go/constant/value.go
index 630581047a203f01d6e6c6af3a1b9f543d317a04..310814df71c24fb07e3d92da08ad637925cf4529 100644 (file)
--- a/src/go/constant/value.go
+++ b/src/go/constant/value.go
@@ -96,7 +96,7 @@ func (x stringVal) String() string {
                // only the first maxLen-3 runes; then add "...".
                i := 0
                for n := 0; n < maxLen-3; n++ {
-                       _, size := utf8.DecodeRuneInString(s)
+                       _, size := utf8.DecodeRuneInString(s[i:])
                        i += size
                }
                s = s[:i] + "..."

diff --git a/src/go/constant/value_test.go b/src/go/constant/value_test.go
index de1ab0267a45f4505b7b3235ba0777bbadf08097..dbd96c07a310b8795339c9cd7f3ec55d161967d8 100644 (file)
--- a/src/go/constant/value_test.go
+++ b/src/go/constant/value_test.go
@@ -204,6 +204,7 @@ func eql(x, y Value) bool {
 // String tests
 
 var xxx = strings.Repeat("x", 68)
+var issue14262 = `"بموجب الشروط التالية نسب المصنف — يجب عليك أن تنسب العمل بالطريقة التي تحددها المؤلف أو المرخص (ولكن ليس بأي حال من الأحوال أن توحي وتقترح بتحول أو استخدامك للعمل).  المشاركة على قدم المساواة — إذا كنت يعدل ، والتغيير ، أو الاستفادة من هذا العمل ، قد ينتج عن توزيع العمل إلا في ظل تشابه او تطابق فى واحد لهذا الترخيص."`
 
 var stringTests = []struct {
        input, short, exact string
@@ -225,6 +226,7 @@ var stringTests = []struct {
        {`"` + xxx + `xx"`, `"` + xxx + `xx"`, `"` + xxx + `xx"`},
        {`"` + xxx + `xxx"`, `"` + xxx + `...`, `"` + xxx + `xxx"`},
        {`"` + xxx + xxx + `xxx"`, `"` + xxx + `...`, `"` + xxx + xxx + `xxx"`},
+       {issue14262, `"بموجب الشروط التالية نسب المصنف — يجب عليك أن تنسب العمل بالطريقة ال...`, issue14262},
 
        // Int
        {"0", "0", "0"},

diff --git a/src/go/types/expr.go b/src/go/types/expr.go
index 942d3fd5f737040da4a63a12969cddb26cb07f8e..f7c4a173785b531a21a54e93d6e09f1611e03c76 100644 (file)
--- a/src/go/types/expr.go
+++ b/src/go/types/expr.go
@@ -184,7 +184,8 @@ func roundFloat64(x constant.Value) constant.Value {
 // provided (only needed for int/uint sizes).
 //
 // If rounded != nil, *rounded is set to the rounded value of x for
-// representable floating-point values; it is left alone otherwise.
+// representable floating-point and complex values, and to an Int
+// value for integer values; it is left alone otherwise.
 // It is ok to provide the addressof the first argument for rounded.
 func representableConst(x constant.Value, conf *Config, typ *Basic, rounded *constant.Value) bool {
        if x.Kind() == constant.Unknown {
@@ -197,6 +198,9 @@ func representableConst(x constant.Value, conf *Config, typ *Basic, rounded *con
                if x.Kind() != constant.Int {
                        return false
                }
+               if rounded != nil {
+                       *rounded = x
+               }
                if x, ok := constant.Int64Val(x); ok {
                        switch typ.kind {
                        case Int:
@@ -808,8 +812,6 @@ func (check *Checker) binary(x *operand, e *ast.BinaryExpr, lhs, rhs ast.Expr, o
                typ := x.typ.Underlying().(*Basic)
                // force integer division of integer operands
                if op == token.QUO && isInteger(typ) {
-                       xval = constant.ToInt(xval)
-                       yval = constant.ToInt(yval)
                        op = token.QUO_ASSIGN
                }
                x.val = constant.BinaryOp(xval, op, yval)

diff --git a/src/go/types/testdata/issues.src b/src/go/types/testdata/issues.src
index 564d0649b2f73f456ee026d26a98a84672561036..4fe0c629386776b583188ef35bff3f7d9ea7ebf2 100644 (file)
--- a/src/go/types/testdata/issues.src
+++ b/src/go/types/testdata/issues.src
@@ -153,3 +153,20 @@ func issue10260() {
        make(chan I1) <- i0 /* ERROR cannot use .* in send: missing method foo */
        make(chan I1) <- i2 /* ERROR cannot use .* in send: wrong type for method foo */
 }
+
+// Check that constants representable as integers are in integer form
+// before being used in operations that are only defined on integers.
+func issue14229() {
+       // from the issue
+       const _ = int64(-1<<63) % 1e6
+
+       // related
+       const (
+               a int = 3
+               b = 4.0
+               _ = a / b
+               _ = a % b
+               _ = b / a
+               _ = b % a
+       )
+}

diff --git a/src/vendor/golang.org/x/net/http2/hpack/encode.go b/src/internal/golang.org/x/net/http2/hpack/encode.go
similarity index 100%
rename from src/vendor/golang.org/x/net/http2/hpack/encode.go
rename to src/internal/golang.org/x/net/http2/hpack/encode.go

diff --git a/src/vendor/golang.org/x/net/http2/hpack/encode_test.go b/src/internal/golang.org/x/net/http2/hpack/encode_test.go
similarity index 100%
rename from src/vendor/golang.org/x/net/http2/hpack/encode_test.go
rename to src/internal/golang.org/x/net/http2/hpack/encode_test.go

diff --git a/src/vendor/golang.org/x/net/http2/hpack/hpack.go b/src/internal/golang.org/x/net/http2/hpack/hpack.go
similarity index 100%
rename from src/vendor/golang.org/x/net/http2/hpack/hpack.go
rename to src/internal/golang.org/x/net/http2/hpack/hpack.go

diff --git a/src/vendor/golang.org/x/net/http2/hpack/hpack_test.go b/src/internal/golang.org/x/net/http2/hpack/hpack_test.go
similarity index 100%
rename from src/vendor/golang.org/x/net/http2/hpack/hpack_test.go
rename to src/internal/golang.org/x/net/http2/hpack/hpack_test.go

diff --git a/src/vendor/golang.org/x/net/http2/hpack/huffman.go b/src/internal/golang.org/x/net/http2/hpack/huffman.go
similarity index 100%
rename from src/vendor/golang.org/x/net/http2/hpack/huffman.go
rename to src/internal/golang.org/x/net/http2/hpack/huffman.go

diff --git a/src/vendor/golang.org/x/net/http2/hpack/tables.go b/src/internal/golang.org/x/net/http2/hpack/tables.go
similarity index 100%
rename from src/vendor/golang.org/x/net/http2/hpack/tables.go
rename to src/internal/golang.org/x/net/http2/hpack/tables.go

diff --git a/src/net/http/client.go b/src/net/http/client.go
index faac5d4e2e74b7fc784e7644d6a86d130801e69d..3106d229da6f7c2c448c397980c540f5cf1315e1 100644 (file)
--- a/src/net/http/client.go
+++ b/src/net/http/client.go
@@ -445,6 +445,7 @@ func (c *Client) doFollowingRedirects(ireq *Request, shouldRedirect func(int) bo
        for redirect := 0; ; redirect++ {
                if redirect != 0 {
                        nreq := new(Request)
+                       nreq.Cancel = ireq.Cancel
                        nreq.Method = ireq.Method
                        if ireq.Method == "POST" || ireq.Method == "PUT" {
                                nreq.Method = "GET"

diff --git a/src/net/http/client_test.go b/src/net/http/client_test.go
index cfad71e0295f1025d04baf846fc673bf1ed17fe6..8939dc8baf9cc9ac4e95784fac3ca897543c5f4b 100644 (file)
--- a/src/net/http/client_test.go
+++ b/src/net/http/client_test.go
@@ -240,7 +240,9 @@ func TestClientRedirects(t *testing.T) {
 
        var checkErr error
        var lastVia []*Request
-       c = &Client{CheckRedirect: func(_ *Request, via []*Request) error {
+       var lastReq *Request
+       c = &Client{CheckRedirect: func(req *Request, via []*Request) error {
+               lastReq = req
                lastVia = via
                return checkErr
        }}
@@ -260,6 +262,20 @@ func TestClientRedirects(t *testing.T) {
                t.Errorf("expected lastVia to have contained %d elements; got %d", e, g)
        }
 
+       // Test that Request.Cancel is propagated between requests (Issue 14053)
+       creq, _ := NewRequest("HEAD", ts.URL, nil)
+       cancel := make(chan struct{})
+       creq.Cancel = cancel
+       if _, err := c.Do(creq); err != nil {
+               t.Fatal(err)
+       }
+       if lastReq == nil {
+               t.Fatal("didn't see redirect")
+       }
+       if lastReq.Cancel != cancel {
+               t.Errorf("expected lastReq to have the cancel channel set on the inital req")
+       }
+
        checkErr = errors.New("no redirects allowed")
        res, err = c.Get(ts.URL)
        if urlError, ok := err.(*url.Error); !ok || urlError.Err != checkErr {

diff --git a/src/net/http/clientserver_test.go b/src/net/http/clientserver_test.go
index 9c1aa7920e347c5b0815a8fea5f631ca6dd1e19a..fbaa805712b157a50d35c7c9ae99694ae97e8949 100644 (file)
--- a/src/net/http/clientserver_test.go
+++ b/src/net/http/clientserver_test.go
@@ -20,6 +20,7 @@ import (
        "net/url"
        "os"
        "reflect"
+       "runtime"
        "sort"
        "strings"
        "sync"
@@ -999,6 +1000,51 @@ func TestTransportDiscardsUnneededConns(t *testing.T) {
        t.Errorf("%d connections opened, %d closed; want %d to close", open, close, open-1)
 }
 
+// tests that Transport doesn't retain a pointer to the provided request.
+func TestTransportGCRequest_Body_h1(t *testing.T)   { testTransportGCRequest(t, h1Mode, true) }
+func TestTransportGCRequest_Body_h2(t *testing.T)   { testTransportGCRequest(t, h2Mode, true) }
+func TestTransportGCRequest_NoBody_h1(t *testing.T) { testTransportGCRequest(t, h1Mode, false) }
+func TestTransportGCRequest_NoBody_h2(t *testing.T) { testTransportGCRequest(t, h2Mode, false) }
+func testTransportGCRequest(t *testing.T, h2, body bool) {
+       defer afterTest(t)
+       cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) {
+               ioutil.ReadAll(r.Body)
+               if body {
+                       io.WriteString(w, "Hello.")
+               }
+       }))
+       defer cst.close()
+
+       didGC := make(chan struct{})
+       (func() {
+               body := strings.NewReader("some body")
+               req, _ := NewRequest("POST", cst.ts.URL, body)
+               runtime.SetFinalizer(req, func(*Request) { close(didGC) })
+               res, err := cst.c.Do(req)
+               if err != nil {
+                       t.Fatal(err)
+               }
+               if _, err := ioutil.ReadAll(res.Body); err != nil {
+                       t.Fatal(err)
+               }
+               if err := res.Body.Close(); err != nil {
+                       t.Fatal(err)
+               }
+       })()
+       timeout := time.NewTimer(5 * time.Second)
+       defer timeout.Stop()
+       for {
+               select {
+               case <-didGC:
+                       return
+               case <-time.After(100 * time.Millisecond):
+                       runtime.GC()
+               case <-timeout.C:
+                       t.Fatal("never saw GC of request")
+               }
+       }
+}
+
 type noteCloseConn struct {
        net.Conn
        closeFunc func()

diff --git a/src/net/http/fs.go b/src/net/http/fs.go
index c41d001d8f12e12c64753d4e4cd3573f6f3210f1..f61c138c1d944390f3fc1f29d9e7d382f1e6e601 100644 (file)
--- a/src/net/http/fs.go
+++ b/src/net/http/fs.go
@@ -451,15 +451,44 @@ func localRedirect(w ResponseWriter, r *Request, newPath string) {
 // ServeFile replies to the request with the contents of the named
 // file or directory.
 //
+// If the provided file or direcory name is a relative path, it is
+// interpreted relative to the current directory and may ascend to parent
+// directories. If the provided name is constructed from user input, it
+// should be sanitized before calling ServeFile. As a precaution, ServeFile
+// will reject requests where r.URL.Path contains a ".." path element.
+//
 // As a special case, ServeFile redirects any request where r.URL.Path
 // ends in "/index.html" to the same path, without the final
 // "index.html". To avoid such redirects either modify the path or
 // use ServeContent.
 func ServeFile(w ResponseWriter, r *Request, name string) {
+       if containsDotDot(r.URL.Path) {
+               // Too many programs use r.URL.Path to construct the argument to
+               // serveFile. Reject the request under the assumption that happened
+               // here and ".." may not be wanted.
+               // Note that name might not contain "..", for example if code (still
+               // incorrectly) used filepath.Join(myDir, r.URL.Path).
+               Error(w, "invalid URL path", StatusBadRequest)
+               return
+       }
        dir, file := filepath.Split(name)
        serveFile(w, r, Dir(dir), file, false)
 }
 
+func containsDotDot(v string) bool {
+       if !strings.Contains(v, "..") {
+               return false
+       }
+       for _, ent := range strings.FieldsFunc(v, isSlashRune) {
+               if ent == ".." {
+                       return true
+               }
+       }
+       return false
+}
+
+func isSlashRune(r rune) bool { return r == '/' || r == '\\' }
+
 type fileHandler struct {
        root FileSystem
 }

diff --git a/src/net/http/fs_test.go b/src/net/http/fs_test.go
index 2e17d3f4bb675f8b85f35164663233a92871a69c..69d78066cd60560e8b0e2f3802a32e01e61c9793 100644 (file)
--- a/src/net/http/fs_test.go
+++ b/src/net/http/fs_test.go
@@ -5,6 +5,7 @@
 package http_test
 
 import (
+       "bufio"
        "bytes"
        "errors"
        "fmt"
@@ -177,6 +178,36 @@ Cases:
        }
 }
 
+func TestServeFile_DotDot(t *testing.T) {
+       tests := []struct {
+               req        string
+               wantStatus int
+       }{
+               {"/testdata/file", 200},
+               {"/../file", 400},
+               {"/..", 400},
+               {"/../", 400},
+               {"/../foo", 400},
+               {"/..\\foo", 400},
+               {"/file/a", 200},
+               {"/file/a..", 200},
+               {"/file/a/..", 400},
+               {"/file/a\\..", 400},
+       }
+       for _, tt := range tests {
+               req, err := ReadRequest(bufio.NewReader(strings.NewReader("GET " + tt.req + " HTTP/1.1\r\nHost: foo\r\n\r\n")))
+               if err != nil {
+                       t.Errorf("bad request %q: %v", tt.req, err)
+                       continue
+               }
+               rec := httptest.NewRecorder()
+               ServeFile(rec, req, "testdata/file")
+               if rec.Code != tt.wantStatus {
+                       t.Errorf("for request %q, status = %d; want %d", tt.req, rec.Code, tt.wantStatus)
+               }
+       }
+}
+
 var fsRedirectTestData = []struct {
        original, redirect string
 }{

diff --git a/src/net/http/h2_bundle.go b/src/net/http/h2_bundle.go
index cd530f16cd0c6e85f812af6e842e5fed03ec7de0..c4faccc7a8d2561c0e3e41fd74a9ea923bc36e43 100644 (file)
--- a/src/net/http/h2_bundle.go
+++ b/src/net/http/h2_bundle.go
@@ -24,6 +24,7 @@ import (
        "encoding/binary"
        "errors"
        "fmt"
+       "internal/golang.org/x/net/http2/hpack"
        "io"
        "io/ioutil"
        "log"
@@ -31,14 +32,13 @@ import (
        "net/textproto"
        "net/url"
        "os"
+       "reflect"
        "runtime"
        "sort"
        "strconv"
        "strings"
        "sync"
        "time"
-
-       "golang.org/x/net/http2/hpack"
 )
 
 // ClientConnPool manages a pool of HTTP/2 client connections.
@@ -2065,13 +2065,62 @@ func (s http2SettingID) String() string {
        return fmt.Sprintf("UNKNOWN_SETTING_%d", uint16(s))
 }
 
-func http2validHeader(v string) bool {
+var (
+       http2errInvalidHeaderFieldName  = errors.New("http2: invalid header field name")
+       http2errInvalidHeaderFieldValue = errors.New("http2: invalid header field value")
+)
+
+// validHeaderFieldName reports whether v is a valid header field name (key).
+//  RFC 7230 says:
+//   header-field   = field-name ":" OWS field-value OWS
+//   field-name     = token
+//   tchar = "!" / "#" / "$" / "%" / "&" / "'" / "*" / "+" / "-" / "." /
+//           "^" / "_" / "
+// Further, http2 says:
+//   "Just as in HTTP/1.x, header field names are strings of ASCII
+//   characters that are compared in a case-insensitive
+//   fashion. However, header field names MUST be converted to
+//   lowercase prior to their encoding in HTTP/2. "
+func http2validHeaderFieldName(v string) bool {
        if len(v) == 0 {
                return false
        }
        for _, r := range v {
+               if int(r) >= len(http2isTokenTable) || ('A' <= r && r <= 'Z') {
+                       return false
+               }
+               if !http2isTokenTable[byte(r)] {
+                       return false
+               }
+       }
+       return true
+}
 
-               if r >= 127 || ('A' <= r && r <= 'Z') {
+// validHeaderFieldValue reports whether v is a valid header field value.
+//
+// RFC 7230 says:
+//  field-value    = *( field-content / obs-fold )
+//  obj-fold       =  N/A to http2, and deprecated
+//  field-content  = field-vchar [ 1*( SP / HTAB ) field-vchar ]
+//  field-vchar    = VCHAR / obs-text
+//  obs-text       = %x80-FF
+//  VCHAR          = "any visible [USASCII] character"
+//
+// http2 further says: "Similarly, HTTP/2 allows header field values
+// that are not valid. While most of the values that can be encoded
+// will not alter header field parsing, carriage return (CR, ASCII
+// 0xd), line feed (LF, ASCII 0xa), and the zero character (NUL, ASCII
+// 0x0) might be exploited by an attacker if they are translated
+// verbatim. Any request or response that contains a character not
+// permitted in a header field value MUST be treated as malformed
+// (Section 8.1.2.6). Valid characters are defined by the
+// field-content ABNF rule in Section 3.2 of [RFC7230]."
+//
+// This function does not (yet?) properly handle the rejection of
+// strings that begin or end with SP or HTAB.
+func http2validHeaderFieldValue(v string) bool {
+       for i := 0; i < len(v); i++ {
+               if b := v[i]; b < ' ' && b != '\t' || b == 0x7f {
                        return false
                }
        }
@@ -2202,6 +2251,90 @@ func (e *http2httpError) Temporary() bool { return true }
 
 var http2errTimeout error = &http2httpError{msg: "http2: timeout awaiting response headers", timeout: true}
 
+var http2isTokenTable = [127]bool{
+       '!':  true,
+       '#':  true,
+       '$':  true,
+       '%':  true,
+       '&':  true,
+       '\'': true,
+       '*':  true,
+       '+':  true,
+       '-':  true,
+       '.':  true,
+       '0':  true,
+       '1':  true,
+       '2':  true,
+       '3':  true,
+       '4':  true,
+       '5':  true,
+       '6':  true,
+       '7':  true,
+       '8':  true,
+       '9':  true,
+       'A':  true,
+       'B':  true,
+       'C':  true,
+       'D':  true,
+       'E':  true,
+       'F':  true,
+       'G':  true,
+       'H':  true,
+       'I':  true,
+       'J':  true,
+       'K':  true,
+       'L':  true,
+       'M':  true,
+       'N':  true,
+       'O':  true,
+       'P':  true,
+       'Q':  true,
+       'R':  true,
+       'S':  true,
+       'T':  true,
+       'U':  true,
+       'W':  true,
+       'V':  true,
+       'X':  true,
+       'Y':  true,
+       'Z':  true,
+       '^':  true,
+       '_':  true,
+       '`':  true,
+       'a':  true,
+       'b':  true,
+       'c':  true,
+       'd':  true,
+       'e':  true,
+       'f':  true,
+       'g':  true,
+       'h':  true,
+       'i':  true,
+       'j':  true,
+       'k':  true,
+       'l':  true,
+       'm':  true,
+       'n':  true,
+       'o':  true,
+       'p':  true,
+       'q':  true,
+       'r':  true,
+       's':  true,
+       't':  true,
+       'u':  true,
+       'v':  true,
+       'w':  true,
+       'x':  true,
+       'y':  true,
+       'z':  true,
+       '|':  true,
+       '~':  true,
+}
+
+type http2connectionStater interface {
+       ConnectionState() tls.ConnectionState
+}
+
 // pipe is a goroutine-safe io.Reader/io.Writer pair.  It's like
 // io.Pipe except there are no PipeReader/PipeWriter halves, and the
 // underlying buffer is an interface. (io.Pipe is always unbuffered)
@@ -2464,28 +2597,76 @@ func http2ConfigureServer(s *Server, conf *http2Server) error {
                if http2testHookOnConn != nil {
                        http2testHookOnConn()
                }
-               conf.handleConn(hs, c, h)
+               conf.ServeConn(c, &http2ServeConnOpts{
+                       Handler:    h,
+                       BaseConfig: hs,
+               })
        }
        s.TLSNextProto[http2NextProtoTLS] = protoHandler
        s.TLSNextProto["h2-14"] = protoHandler
        return nil
 }
 
-func (srv *http2Server) handleConn(hs *Server, c net.Conn, h Handler) {
+// ServeConnOpts are options for the Server.ServeConn method.
+type http2ServeConnOpts struct {
+       // BaseConfig optionally sets the base configuration
+       // for values. If nil, defaults are used.
+       BaseConfig *Server
+
+       // Handler specifies which handler to use for processing
+       // requests. If nil, BaseConfig.Handler is used. If BaseConfig
+       // or BaseConfig.Handler is nil, http.DefaultServeMux is used.
+       Handler Handler
+}
+
+func (o *http2ServeConnOpts) baseConfig() *Server {
+       if o != nil && o.BaseConfig != nil {
+               return o.BaseConfig
+       }
+       return new(Server)
+}
+
+func (o *http2ServeConnOpts) handler() Handler {
+       if o != nil {
+               if o.Handler != nil {
+                       return o.Handler
+               }
+               if o.BaseConfig != nil && o.BaseConfig.Handler != nil {
+                       return o.BaseConfig.Handler
+               }
+       }
+       return DefaultServeMux
+}
+
+// ServeConn serves HTTP/2 requests on the provided connection and
+// blocks until the connection is no longer readable.
+//
+// ServeConn starts speaking HTTP/2 assuming that c has not had any
+// reads or writes. It writes its initial settings frame and expects
+// to be able to read the preface and settings frame from the
+// client. If c has a ConnectionState method like a *tls.Conn, the
+// ConnectionState is used to verify the TLS ciphersuite and to set
+// the Request.TLS field in Handlers.
+//
+// ServeConn does not support h2c by itself. Any h2c support must be
+// implemented in terms of providing a suitably-behaving net.Conn.
+//
+// The opts parameter is optional. If nil, default values are used.
+func (s *http2Server) ServeConn(c net.Conn, opts *http2ServeConnOpts) {
        sc := &http2serverConn{
-               srv:              srv,
-               hs:               hs,
+               srv:              s,
+               hs:               opts.baseConfig(),
                conn:             c,
                remoteAddrStr:    c.RemoteAddr().String(),
                bw:               http2newBufferedWriter(c),
-               handler:          h,
+               handler:          opts.handler(),
                streams:          make(map[uint32]*http2stream),
                readFrameCh:      make(chan http2readFrameResult),
                wantWriteFrameCh: make(chan http2frameWriteMsg, 8),
                wroteFrameCh:     make(chan http2frameWriteResult, 1),
                bodyReadCh:       make(chan http2bodyReadMsg),
                doneServing:      make(chan struct{}),
-               advMaxStreams:    srv.maxConcurrentStreams(),
+               advMaxStreams:    s.maxConcurrentStreams(),
                writeSched: http2writeScheduler{
                        maxFrameSize: http2initialMaxFrameSize,
                },
@@ -2501,10 +2682,10 @@ func (srv *http2Server) handleConn(hs *Server, c net.Conn, h Handler) {
        sc.hpackDecoder.SetMaxStringLength(sc.maxHeaderStringLen())
 
        fr := http2NewFramer(sc.bw, c)
-       fr.SetMaxReadFrameSize(srv.maxReadFrameSize())
+       fr.SetMaxReadFrameSize(s.maxReadFrameSize())
        sc.framer = fr
 
-       if tc, ok := c.(*tls.Conn); ok {
+       if tc, ok := c.(http2connectionStater); ok {
                sc.tlsState = new(tls.ConnectionState)
                *sc.tlsState = tc.ConnectionState()
 
@@ -2517,7 +2698,7 @@ func (srv *http2Server) handleConn(hs *Server, c net.Conn, h Handler) {
 
                }
 
-               if !srv.PermitProhibitedCipherSuites && http2isBadCipher(sc.tlsState.CipherSuite) {
+               if !s.PermitProhibitedCipherSuites && http2isBadCipher(sc.tlsState.CipherSuite) {
 
                        sc.rejectConn(http2ErrCodeInadequateSecurity, fmt.Sprintf("Prohibited TLS 1.2 Cipher Suite: %x", sc.tlsState.CipherSuite))
                        return
@@ -2722,12 +2903,48 @@ func (sc *http2serverConn) logf(format string, args ...interface{}) {
        }
 }
 
+// errno returns v's underlying uintptr, else 0.
+//
+// TODO: remove this helper function once http2 can use build
+// tags. See comment in isClosedConnError.
+func http2errno(v error) uintptr {
+       if rv := reflect.ValueOf(v); rv.Kind() == reflect.Uintptr {
+               return uintptr(rv.Uint())
+       }
+       return 0
+}
+
+// isClosedConnError reports whether err is an error from use of a closed
+// network connection.
+func http2isClosedConnError(err error) bool {
+       if err == nil {
+               return false
+       }
+
+       str := err.Error()
+       if strings.Contains(str, "use of closed network connection") {
+               return true
+       }
+
+       if runtime.GOOS == "windows" {
+               if oe, ok := err.(*net.OpError); ok && oe.Op == "read" {
+                       if se, ok := oe.Err.(*os.SyscallError); ok && se.Syscall == "wsarecv" {
+                               const WSAECONNABORTED = 10053
+                               const WSAECONNRESET = 10054
+                               if n := http2errno(se.Err); n == WSAECONNRESET || n == WSAECONNABORTED {
+                                       return true
+                               }
+                       }
+               }
+       }
+       return false
+}
+
 func (sc *http2serverConn) condlogf(err error, format string, args ...interface{}) {
        if err == nil {
                return
        }
-       str := err.Error()
-       if err == io.EOF || strings.Contains(str, "use of closed network connection") {
+       if err == io.EOF || err == io.ErrUnexpectedEOF || http2isClosedConnError(err) {
 
                sc.vlogf(format, args...)
        } else {
@@ -2741,7 +2958,7 @@ func (sc *http2serverConn) onNewHeaderField(f hpack.HeaderField) {
                sc.vlogf("http2: server decoded %v", f)
        }
        switch {
-       case !http2validHeader(f.Name):
+       case !http2validHeaderFieldValue(f.Value):
                sc.req.invalidHeader = true
        case strings.HasPrefix(f.Name, ":"):
                if sc.req.sawRegularHeader {
@@ -2771,6 +2988,8 @@ func (sc *http2serverConn) onNewHeaderField(f hpack.HeaderField) {
                        return
                }
                *dst = f.Value
+       case !http2validHeaderFieldName(f.Name):
+               sc.req.invalidHeader = true
        default:
                sc.req.sawRegularHeader = true
                sc.req.header.Add(sc.canonicalHeader(f.Name), f.Value)
@@ -2789,10 +3008,10 @@ func (st *http2stream) onNewTrailerField(f hpack.HeaderField) {
                sc.vlogf("http2: server decoded trailer %v", f)
        }
        switch {
-       case !http2validHeader(f.Name):
+       case strings.HasPrefix(f.Name, ":"):
                sc.req.invalidHeader = true
                return
-       case strings.HasPrefix(f.Name, ":"):
+       case !http2validHeaderFieldName(f.Name) || !http2validHeaderFieldValue(f.Value):
                sc.req.invalidHeader = true
                return
        default:
@@ -3242,7 +3461,7 @@ func (sc *http2serverConn) processFrameFromReader(res http2readFrameResult) bool
                        sc.goAway(http2ErrCodeFrameSize)
                        return true
                }
-               clientGone := err == io.EOF || strings.Contains(err.Error(), "use of closed network connection")
+               clientGone := err == io.EOF || err == io.ErrUnexpectedEOF || http2isClosedConnError(err)
                if clientGone {
 
                        return false
@@ -3271,7 +3490,7 @@ func (sc *http2serverConn) processFrameFromReader(res http2readFrameResult) bool
                return true
        default:
                if res.err != nil {
-                       sc.logf("http2: server closing client connection; error reading frame from client %s: %v", sc.conn.RemoteAddr(), err)
+                       sc.vlogf("http2: server closing client connection; error reading frame from client %s: %v", sc.conn.RemoteAddr(), err)
                } else {
                        sc.logf("http2: server closing client connection: %v", err)
                }
@@ -4051,7 +4270,9 @@ func (rws *http2responseWriterState) declareTrailer(k string) {
 
                return
        }
-       rws.trailers = append(rws.trailers, k)
+       if !http2strSliceContains(rws.trailers, k) {
+               rws.trailers = append(rws.trailers, k)
+       }
 }
 
 // writeChunk writes chunks from the bufio.Writer. But because
@@ -4119,6 +4340,10 @@ func (rws *http2responseWriterState) writeChunk(p []byte) (n int, err error) {
                return 0, nil
        }
 
+       if rws.handlerDone {
+               rws.promoteUndeclaredTrailers()
+       }
+
        endStream := rws.handlerDone && !rws.hasTrailers()
        if len(p) > 0 || endStream {
 
@@ -4139,6 +4364,53 @@ func (rws *http2responseWriterState) writeChunk(p []byte) (n int, err error) {
        return len(p), nil
 }
 
+// TrailerPrefix is a magic prefix for ResponseWriter.Header map keys
+// that, if present, signals that the map entry is actually for
+// the response trailers, and not the response headers. The prefix
+// is stripped after the ServeHTTP call finishes and the values are
+// sent in the trailers.
+//
+// This mechanism is intended only for trailers that are not known
+// prior to the headers being written. If the set of trailers is fixed
+// or known before the header is written, the normal Go trailers mechanism
+// is preferred:
+//    https://golang.org/pkg/net/http/#ResponseWriter
+//    https://golang.org/pkg/net/http/#example_ResponseWriter_trailers
+const http2TrailerPrefix = "Trailer:"
+
+// promoteUndeclaredTrailers permits http.Handlers to set trailers
+// after the header has already been flushed. Because the Go
+// ResponseWriter interface has no way to set Trailers (only the
+// Header), and because we didn't want to expand the ResponseWriter
+// interface, and because nobody used trailers, and because RFC 2616
+// says you SHOULD (but not must) predeclare any trailers in the
+// header, the official ResponseWriter rules said trailers in Go must
+// be predeclared, and then we reuse the same ResponseWriter.Header()
+// map to mean both Headers and Trailers.  When it's time to write the
+// Trailers, we pick out the fields of Headers that were declared as
+// trailers. That worked for a while, until we found the first major
+// user of Trailers in the wild: gRPC (using them only over http2),
+// and gRPC libraries permit setting trailers mid-stream without
+// predeclarnig them. So: change of plans. We still permit the old
+// way, but we also permit this hack: if a Header() key begins with
+// "Trailer:", the suffix of that key is a Trailer. Because ':' is an
+// invalid token byte anyway, there is no ambiguity. (And it's already
+// filtered out) It's mildly hacky, but not terrible.
+//
+// This method runs after the Handler is done and promotes any Header
+// fields to be trailers.
+func (rws *http2responseWriterState) promoteUndeclaredTrailers() {
+       for k, vv := range rws.handlerHeader {
+               if !strings.HasPrefix(k, http2TrailerPrefix) {
+                       continue
+               }
+               trailerKey := strings.TrimPrefix(k, http2TrailerPrefix)
+               rws.declareTrailer(trailerKey)
+               rws.handlerHeader[CanonicalHeaderKey(trailerKey)] = vv
+       }
+       sort.Strings(rws.trailers)
+}
+
 func (w *http2responseWriter) Flush() {
        rws := w.rws
        if rws == nil {
@@ -4654,10 +4926,7 @@ func (t *http2Transport) NewClientConn(c net.Conn) (*http2ClientConn, error) {
 
        cc.henc = hpack.NewEncoder(&cc.hbuf)
 
-       type connectionStater interface {
-               ConnectionState() tls.ConnectionState
-       }
-       if cs, ok := c.(connectionStater); ok {
+       if cs, ok := c.(http2connectionStater); ok {
                state := cs.ConnectionState()
                cc.tlsState = &state
        }
@@ -4808,7 +5077,27 @@ func (cc *http2ClientConn) responseHeaderTimeout() time.Duration {
        return 0
 }
 
+// checkConnHeaders checks whether req has any invalid connection-level headers.
+// per RFC 7540 section 8.1.2.2: Connection-Specific Header Fields.
+// Certain headers are special-cased as okay but not transmitted later.
+func http2checkConnHeaders(req *Request) error {
+       if v := req.Header.Get("Upgrade"); v != "" {
+               return errors.New("http2: invalid Upgrade request header")
+       }
+       if v := req.Header.Get("Transfer-Encoding"); (v != "" && v != "chunked") || len(req.Header["Transfer-Encoding"]) > 1 {
+               return errors.New("http2: invalid Transfer-Encoding request header")
+       }
+       if v := req.Header.Get("Connection"); (v != "" && v != "close" && v != "keep-alive") || len(req.Header["Connection"]) > 1 {
+               return errors.New("http2: invalid Connection request header")
+       }
+       return nil
+}
+
 func (cc *http2ClientConn) RoundTrip(req *Request) (*Response, error) {
+       if err := http2checkConnHeaders(req); err != nil {
+               return nil, err
+       }
+
        trailers, err := http2commaSeparatedTrailers(req)
        if err != nil {
                return nil, err
@@ -5114,10 +5403,14 @@ func (cc *http2ClientConn) encodeHeaders(req *Request, addGzipHeader bool, trail
        var didUA bool
        for k, vv := range req.Header {
                lowKey := strings.ToLower(k)
-               if lowKey == "host" || lowKey == "content-length" {
+               switch lowKey {
+               case "host", "content-length":
+
                        continue
-               }
-               if lowKey == "user-agent" {
+               case "connection", "proxy-connection", "transfer-encoding", "upgrade":
+
+                       continue
+               case "user-agent":
 
                        didUA = true
                        if len(vv) < 1 {
@@ -5225,8 +5518,9 @@ func (cc *http2ClientConn) streamByID(id uint32, andRemove bool) *http2clientStr
 
 // clientConnReadLoop is the state owned by the clientConn's frame-reading readLoop.
 type http2clientConnReadLoop struct {
-       cc        *http2ClientConn
-       activeRes map[uint32]*http2clientStream // keyed by streamID
+       cc            *http2ClientConn
+       activeRes     map[uint32]*http2clientStream // keyed by streamID
+       closeWhenIdle bool
 
        hdec *hpack.Decoder
 
@@ -5283,7 +5577,7 @@ func (rl *http2clientConnReadLoop) cleanup() {
 
 func (rl *http2clientConnReadLoop) run() error {
        cc := rl.cc
-       closeWhenIdle := cc.t.disableKeepAlives()
+       rl.closeWhenIdle = cc.t.disableKeepAlives()
        gotReply := false
        for {
                f, err := cc.fr.ReadFrame()
@@ -5332,7 +5626,7 @@ func (rl *http2clientConnReadLoop) run() error {
                if err != nil {
                        return err
                }
-               if closeWhenIdle && gotReply && maybeIdle && len(rl.activeRes) == 0 {
+               if rl.closeWhenIdle && gotReply && maybeIdle && len(rl.activeRes) == 0 {
                        cc.closeIfIdle()
                }
        }
@@ -5442,10 +5736,10 @@ func (rl *http2clientConnReadLoop) processHeaderBlockFragment(frag []byte, strea
                        res.ContentLength = -1
                        res.Body = &http2gzipReader{body: res.Body}
                }
+               rl.activeRes[cs.ID] = cs
        }
 
        cs.resTrailer = &res.Trailer
-       rl.activeRes[cs.ID] = cs
        cs.resc <- http2resAndError{res: res}
        rl.nextRes = nil
        return nil
@@ -5583,6 +5877,9 @@ func (rl *http2clientConnReadLoop) endStream(cs *http2clientStream) {
        }
        cs.bufPipe.closeWithErrorAndCode(err, code)
        delete(rl.activeRes, cs.ID)
+       if cs.req.Close || cs.req.Header.Get("Connection") == "close" {
+               rl.closeWhenIdle = true
+       }
 }
 
 func (cs *http2clientStream) copyTrailers() {
@@ -5697,7 +5994,6 @@ func (cc *http2ClientConn) writeStreamReset(streamID uint32, code http2ErrCode,
 
 var (
        http2errResponseHeaderListSize = errors.New("http2: response header list larger than advertised limit")
-       http2errInvalidHeaderKey       = errors.New("http2: invalid header key")
        http2errPseudoTrailers         = errors.New("http2: invalid pseudo header in trailers")
 )
 
@@ -5714,8 +6010,8 @@ func (rl *http2clientConnReadLoop) checkHeaderField(f hpack.HeaderField) bool {
                return false
        }
 
-       if !http2validHeader(f.Name) {
-               rl.reqMalformed = http2errInvalidHeaderKey
+       if !http2validHeaderFieldValue(f.Value) {
+               rl.reqMalformed = http2errInvalidHeaderFieldValue
                return false
        }
 
@@ -5726,6 +6022,10 @@ func (rl *http2clientConnReadLoop) checkHeaderField(f hpack.HeaderField) bool {
                        return false
                }
        } else {
+               if !http2validHeaderFieldName(f.Name) {
+                       rl.reqMalformed = http2errInvalidHeaderFieldName
+                       return false
+               }
                rl.sawRegHeader = true
        }
 
@@ -6086,8 +6386,16 @@ func http2encodeHeaders(enc *hpack.Encoder, h Header, keys []string) {
        for _, k := range keys {
                vv := h[k]
                k = http2lowerHeader(k)
+               if !http2validHeaderFieldName(k) {
+
+                       continue
+               }
                isTE := k == "transfer-encoding"
                for _, v := range vv {
+                       if !http2validHeaderFieldValue(v) {
+
+                               continue
+                       }
 
                        if isTE && v != "trailers" {
                                continue

diff --git a/src/net/http/httputil/dump.go b/src/net/http/httputil/dump.go
index 6fe8fea110b7cafadf4b92776ee7e5f7d59609ea..e22cc66dbfccfee8e211832226e2e009e995eb79 100644 (file)
--- a/src/net/http/httputil/dump.go
+++ b/src/net/http/httputil/dump.go
@@ -25,10 +25,10 @@ import (
 func drainBody(b io.ReadCloser) (r1, r2 io.ReadCloser, err error) {
        var buf bytes.Buffer
        if _, err = buf.ReadFrom(b); err != nil {
-               return nil, nil, err
+               return nil, b, err
        }
        if err = b.Close(); err != nil {
-               return nil, nil, err
+               return nil, b, err
        }
        return ioutil.NopCloser(&buf), ioutil.NopCloser(bytes.NewReader(buf.Bytes())), nil
 }
@@ -175,15 +175,22 @@ func dumpAsReceived(req *http.Request, w io.Writer) error {
        return nil
 }
 
-// DumpRequest returns the as-received wire representation of req, optionally
-// including the request body, for debugging. It is for use in servers; use
-// DumpRequestOut for client requests.
+// DumpRequest returns the given request in its HTTP/1.x wire
+// representation. It should only be used by servers to debug client
+// requests. The returned representation is an approximation only;
+// some details of the initial request are lost while parsing it into
+// an http.Request. In particular, the order and case of header field
+// names are lost. The order of values in multi-valued headers is kept
+// intact. HTTP/2 requests are dumped in HTTP/1.x form, not in their
+// original binary representations.
+//
+// If body is true, DumpRequest also returns the body. To do so, it
+// consumes req.Body and then replaces it with a new io.ReadCloser
+// that yields the same bytes. If DumpRequest returns an error,
+// the state of req is undefined.
 //
-// DumpRequest is semantically a no-op, but in order to
-// dump the body, it reads the body data into memory and
-// changes req.Body to refer to the in-memory copy.
 // The documentation for http.Request.Write details which fields
-// of req are used.
+// of req are included in the dump.
 func DumpRequest(req *http.Request, body bool) (dump []byte, err error) {
        save := req.Body
        if !body || req.Body == nil {
@@ -191,7 +198,7 @@ func DumpRequest(req *http.Request, body bool) (dump []byte, err error) {
        } else {
                save, req.Body, err = drainBody(req.Body)
                if err != nil {
-                       return
+                       return nil, err
                }
        }
 
@@ -285,7 +292,7 @@ func DumpResponse(resp *http.Response, body bool) (dump []byte, err error) {
        } else {
                save, resp.Body, err = drainBody(resp.Body)
                if err != nil {
-                       return
+                       return nil, err
                }
        }
        err = resp.Write(&b)

diff --git a/src/net/http/httputil/reverseproxy.go b/src/net/http/httputil/reverseproxy.go
index 4dba352a4fa5110f94c2e3a012533fc2784e639f..54411caeca8f90472cf0aa220d53bf906bee0f79 100644 (file)
--- a/src/net/http/httputil/reverseproxy.go
+++ b/src/net/http/httputil/reverseproxy.go
@@ -106,11 +106,12 @@ func copyHeader(dst, src http.Header) {
 // http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html
 var hopHeaders = []string{
        "Connection",
+       "Proxy-Connection", // non-standard but still sent by libcurl and rejected by e.g. google
        "Keep-Alive",
        "Proxy-Authenticate",
        "Proxy-Authorization",
-       "Te", // canonicalized version of "TE"
-       "Trailers",
+       "Te",      // canonicalized version of "TE"
+       "Trailer", // not Trailers per URL above; http://www.rfc-editor.org/errata_search.php?eid=4522
        "Transfer-Encoding",
        "Upgrade",
 }

diff --git a/src/net/http/httputil/reverseproxy_test.go b/src/net/http/httputil/reverseproxy_test.go
index 7f203d878f544ec5d222c6b91447542411296fe5..0849427b85cce40f6e7a262d0db2806c2bb8f209 100644 (file)
--- a/src/net/http/httputil/reverseproxy_test.go
+++ b/src/net/http/httputil/reverseproxy_test.go
@@ -45,9 +45,13 @@ func TestReverseProxy(t *testing.T) {
                if c := r.Header.Get("Upgrade"); c != "" {
                        t.Errorf("handler got Upgrade header value %q", c)
                }
+               if c := r.Header.Get("Proxy-Connection"); c != "" {
+                       t.Errorf("handler got Proxy-Connection header value %q", c)
+               }
                if g, e := r.Host, "some-name"; g != e {
                        t.Errorf("backend got Host header %q, want %q", g, e)
                }
+               w.Header().Set("Trailers", "not a special header field name")
                w.Header().Set("Trailer", "X-Trailer")
                w.Header().Set("X-Foo", "bar")
                w.Header().Set("Upgrade", "foo")
@@ -71,6 +75,7 @@ func TestReverseProxy(t *testing.T) {
        getReq, _ := http.NewRequest("GET", frontend.URL, nil)
        getReq.Host = "some-name"
        getReq.Header.Set("Connection", "close")
+       getReq.Header.Set("Proxy-Connection", "should be deleted")
        getReq.Header.Set("Upgrade", "foo")
        getReq.Close = true
        res, err := http.DefaultClient.Do(getReq)
@@ -86,6 +91,9 @@ func TestReverseProxy(t *testing.T) {
        if c := res.Header.Get(fakeHopHeader); c != "" {
                t.Errorf("got %s header value %q", fakeHopHeader, c)
        }
+       if g, e := res.Header.Get("Trailers"), "not a special header field name"; g != e {
+               t.Errorf("header Trailers = %q; want %q", g, e)
+       }
        if g, e := len(res.Header["X-Multi-Value"]), 2; g != e {
                t.Errorf("got %d X-Multi-Value header values; expected %d", g, e)
        }

diff --git a/src/net/http/internal/chunked.go b/src/net/http/internal/chunked.go
index 3967ad614f465aa57491e87a824fd79c85bb9608..2e62c00d5db5013e9e73c26cc59179b385f3e261 100644 (file)
--- a/src/net/http/internal/chunked.go
+++ b/src/net/http/internal/chunked.go
@@ -220,8 +220,7 @@ type FlushAfterChunkWriter struct {
 }
 
 func parseHexUint(v []byte) (n uint64, err error) {
-       for _, b := range v {
-               n <<= 4
+       for i, b := range v {
                switch {
                case '0' <= b && b <= '9':
                        b = b - '0'
@@ -232,6 +231,10 @@ func parseHexUint(v []byte) (n uint64, err error) {
                default:
                        return 0, errors.New("invalid byte in chunk length")
                }
+               if i == 16 {
+                       return 0, errors.New("http chunk length too large")
+               }
+               n <<= 4
                n |= uint64(b)
        }
        return

diff --git a/src/net/http/internal/chunked_test.go b/src/net/http/internal/chunked_test.go
index 7c1c91662fdd50f3ebdb1ee47d1d7f46cd72f73f..a136dc99a65fc82271839e8f1245539a50d09601 100644 (file)
--- a/src/net/http/internal/chunked_test.go
+++ b/src/net/http/internal/chunked_test.go
@@ -139,19 +139,35 @@ func TestChunkReaderAllocs(t *testing.T) {
 }
 
 func TestParseHexUint(t *testing.T) {
+       type testCase struct {
+               in      string
+               want    uint64
+               wantErr string
+       }
+       tests := []testCase{
+               {"x", 0, "invalid byte in chunk length"},
+               {"0000000000000000", 0, ""},
+               {"0000000000000001", 1, ""},
+               {"ffffffffffffffff", 1<<64 - 1, ""},
+               {"000000000000bogus", 0, "invalid byte in chunk length"},
+               {"00000000000000000", 0, "http chunk length too large"}, // could accept if we wanted
+               {"10000000000000000", 0, "http chunk length too large"},
+               {"00000000000000001", 0, "http chunk length too large"}, // could accept if we wanted
+       }
        for i := uint64(0); i <= 1234; i++ {
-               line := []byte(fmt.Sprintf("%x", i))
-               got, err := parseHexUint(line)
-               if err != nil {
-                       t.Fatalf("on %d: %v", i, err)
-               }
-               if got != i {
-                       t.Errorf("for input %q = %d; want %d", line, got, i)
-               }
+               tests = append(tests, testCase{in: fmt.Sprintf("%x", i), want: i})
        }
-       _, err := parseHexUint([]byte("bogus"))
-       if err == nil {
-               t.Error("expected error on bogus input")
+       for _, tt := range tests {
+               got, err := parseHexUint([]byte(tt.in))
+               if tt.wantErr != "" {
+                       if !strings.Contains(fmt.Sprint(err), tt.wantErr) {
+                               t.Errorf("parseHexUint(%q) = %v, %v; want error %q", tt.in, got, err, tt.wantErr)
+                       }
+               } else {
+                       if err != nil || got != tt.want {
+                               t.Errorf("parseHexUint(%q) = %v, %v; want %v", tt.in, got, err, tt.want)
+                       }
+               }
        }
 }
 

diff --git a/src/net/http/request.go b/src/net/http/request.go
index 16c5bb43ac4d4c7b7974dfa0c6e1c50c0c28eef3..8cdab02af5a057ca0382fcb17034a4086547a421 100644 (file)
--- a/src/net/http/request.go
+++ b/src/net/http/request.go
@@ -99,30 +99,37 @@ type Request struct {
        ProtoMajor int    // 1
        ProtoMinor int    // 0
 
-       // A header maps request lines to their values.
-       // If the header says
+       // Header contains the request header fields either received
+       // by the server or to be sent by the client.
        //
+       // If a server received a request with header lines,
+       //
+       //      Host: example.com
        //      accept-encoding: gzip, deflate
        //      Accept-Language: en-us
-       //      Connection: keep-alive
+       //      fOO: Bar
+       //      foo: two
        //
        // then
        //
        //      Header = map[string][]string{
        //              "Accept-Encoding": {"gzip, deflate"},
        //              "Accept-Language": {"en-us"},
-       //              "Connection": {"keep-alive"},
+       //              "Foo": {"Bar", "two"},
        //      }
        //
-       // HTTP defines that header names are case-insensitive.
-       // The request parser implements this by canonicalizing the
-       // name, making the first character and any characters
-       // following a hyphen uppercase and the rest lowercase.
+       // For incoming requests, the Host header is promoted to the
+       // Request.Host field and removed from the Header map.
        //
-       // For client requests certain headers are automatically
-       // added and may override values in Header.
+       // HTTP defines that header names are case-insensitive. The
+       // request parser implements this by using CanonicalHeaderKey,
+       // making the first character and any characters following a
+       // hyphen uppercase and the rest lowercase.
        //
-       // See the documentation for the Request.Write method.
+       // For client requests, certain headers such as Content-Length
+       // and Connection are automatically written when needed and
+       // values in Header may be ignored. See the documentation
+       // for the Request.Write method.
        Header Header
 
        // Body is the request's body.
@@ -152,8 +159,15 @@ type Request struct {
        TransferEncoding []string
 
        // Close indicates whether to close the connection after
-       // replying to this request (for servers) or after sending
-       // the request (for clients).
+       // replying to this request (for servers) or after sending this
+       // request and reading its response (for clients).
+       //
+       // For server requests, the HTTP server handles this automatically
+       // and this field is not needed by Handlers.
+       //
+       // For client requests, setting this field prevents re-use of
+       // TCP connections between requests to the same hosts, as if
+       // Transport.DisableKeepAlives were set.
        Close bool
 
        // For server requests Host specifies the host on which the

diff --git a/src/net/http/response_test.go b/src/net/http/response_test.go
index b4bf09aa9bdd537683889f14c5eb37f8dc10b2c6..d8a53400cf23d654813d9530466109a0dfb41e0f 100644 (file)
--- a/src/net/http/response_test.go
+++ b/src/net/http/response_test.go
@@ -822,7 +822,7 @@ func TestReadResponseErrors(t *testing.T) {
                if err := matchErr(rerr, tt.wantErr); err != nil {
                        name := tt.name
                        if name == "" {
-                               name = fmt.Sprintf("%i. input %q", i, tt.in)
+                               name = fmt.Sprintf("%d. input %q", i, tt.in)
                        }
                        t.Errorf("%s: %v", name, err)
                }

diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go
index f8cad802d4986a9293c533284c6ca59bc99a342c..384b453ce0ad5860a2fc67ff01537c700145c325 100644 (file)
--- a/src/net/http/serve_test.go
+++ b/src/net/http/serve_test.go
@@ -1039,12 +1039,30 @@ func TestAutomaticHTTP2_Serve(t *testing.T) {
 }
 
 func TestAutomaticHTTP2_ListenAndServe(t *testing.T) {
-       defer afterTest(t)
-       defer SetTestHookServerServe(nil)
        cert, err := tls.X509KeyPair(internal.LocalhostCert, internal.LocalhostKey)
        if err != nil {
                t.Fatal(err)
        }
+       testAutomaticHTTP2_ListenAndServe(t, &tls.Config{
+               Certificates: []tls.Certificate{cert},
+       })
+}
+
+func TestAutomaticHTTP2_ListenAndServe_GetCertificate(t *testing.T) {
+       cert, err := tls.X509KeyPair(internal.LocalhostCert, internal.LocalhostKey)
+       if err != nil {
+               t.Fatal(err)
+       }
+       testAutomaticHTTP2_ListenAndServe(t, &tls.Config{
+               GetCertificate: func(clientHello *tls.ClientHelloInfo) (*tls.Certificate, error) {
+                       return &cert, nil
+               },
+       })
+}
+
+func testAutomaticHTTP2_ListenAndServe(t *testing.T, tlsConf *tls.Config) {
+       defer afterTest(t)
+       defer SetTestHookServerServe(nil)
        var ok bool
        var s *Server
        const maxTries = 5
@@ -1060,10 +1078,8 @@ Try:
                        lnc <- ln
                })
                s = &Server{
-                       Addr: addr,
-                       TLSConfig: &tls.Config{
-                               Certificates: []tls.Certificate{cert},
-                       },
+                       Addr:      addr,
+                       TLSConfig: tlsConf,
                }
                errc := make(chan error, 1)
                go func() { errc <- s.ListenAndServeTLS("", "") }()
@@ -2416,7 +2432,7 @@ func TestCloseNotifierPipelined(t *testing.T) {
        if err != nil {
                t.Fatalf("error dialing: %v", err)
        }
-       diec := make(chan bool, 2)
+       diec := make(chan bool, 1)
        go func() {
                const req = "GET / HTTP/1.1\r\nConnection: keep-alive\r\nHost: foo\r\n\r\n"
                _, err = io.WriteString(conn, req+req) // two requests
@@ -2426,13 +2442,23 @@ func TestCloseNotifierPipelined(t *testing.T) {
                <-diec
                conn.Close()
        }()
+       reqs := 0
+       closes := 0
 For:
        for {
                select {
                case <-gotReq:
-                       diec <- true
+                       reqs++
+                       if reqs > 2 {
+                               t.Fatal("too many requests")
+                       } else if reqs > 1 {
+                               diec <- true
+                       }
                case <-sawClose:
-                       break For
+                       closes++
+                       if closes > 1 {
+                               break For
+                       }
                case <-time.After(5 * time.Second):
                        ts.CloseClientConnections()
                        t.Fatal("timeout")

diff --git a/src/net/http/server.go b/src/net/http/server.go
index 2ec106927b91b0fc1487f2e0f3e18aa7be5fb60a..5e3b6084ae3879be3b14ca5d3dfaddce652256b4 100644 (file)
--- a/src/net/http/server.go
+++ b/src/net/http/server.go
@@ -648,10 +648,12 @@ func (ecr *expectContinueReader) Close() error {
        return ecr.readCloser.Close()
 }
 
-// TimeFormat is the time format to use with
-// time.Parse and time.Time.Format when parsing
-// or generating times in HTTP headers.
-// It is like time.RFC1123 but hard codes GMT as the time zone.
+// TimeFormat is the time format to use when generating times in HTTP
+// headers. It is like time.RFC1123 but hard-codes GMT as the time
+// zone. The time being formatted must be in UTC for Format to
+// generate the correct format.
+//
+// For parsing this time format, see ParseTime.
 const TimeFormat = "Mon, 02 Jan 2006 15:04:05 GMT"
 
 // appendTime is a non-allocating version of []byte(t.UTC().Format(TimeFormat))
@@ -2231,10 +2233,11 @@ func ListenAndServeTLS(addr, certFile, keyFile string, handler Handler) error {
 // Accepted connections are configured to enable TCP keep-alives.
 //
 // Filenames containing a certificate and matching private key for the
-// server must be provided if the Server's TLSConfig.Certificates is
-// not populated. If the certificate is signed by a certificate
-// authority, the certFile should be the concatenation of the server's
-// certificate, any intermediates, and the CA's certificate.
+// server must be provided if neither the Server's TLSConfig.Certificates
+// nor TLSConfig.GetCertificate are populated. If the certificate is
+// signed by a certificate authority, the certFile should be the
+// concatenation of the server's certificate, any intermediates, and
+// the CA's certificate.
 //
 // If srv.Addr is blank, ":https" is used.
 //
@@ -2256,7 +2259,8 @@ func (srv *Server) ListenAndServeTLS(certFile, keyFile string) error {
                config.NextProtos = append(config.NextProtos, "http/1.1")
        }
 
-       if len(config.Certificates) == 0 || certFile != "" || keyFile != "" {
+       configHasCert := len(config.Certificates) > 0 || config.GetCertificate != nil
+       if !configHasCert || certFile != "" || keyFile != "" {
                var err error
                config.Certificates = make([]tls.Certificate, 1)
                config.Certificates[0], err = tls.LoadX509KeyPair(certFile, keyFile)

diff --git a/src/net/http/transport.go b/src/net/http/transport.go
index fc0ae36b519d4810bb135f383216477541b02528..41df906cf2d1d70d3fa1d714ebc4b706f0c692ef 100644 (file)
--- a/src/net/http/transport.go
+++ b/src/net/http/transport.go
@@ -298,6 +298,7 @@ func (t *Transport) RoundTrip(req *Request) (*Response, error) {
                var resp *Response
                if pconn.alt != nil {
                        // HTTP/2 path.
+                       t.setReqCanceler(req, nil) // not cancelable with CancelRequest
                        resp, err = pconn.alt.RoundTrip(req)
                } else {
                        resp, err = pconn.roundTrip(treq)
@@ -397,7 +398,8 @@ func (t *Transport) CloseIdleConnections() {
 // CancelRequest cancels an in-flight request by closing its connection.
 // CancelRequest should only be called after RoundTrip has returned.
 //
-// Deprecated: Use Request.Cancel instead.
+// Deprecated: Use Request.Cancel instead. CancelRequest can not cancel
+// HTTP/2 requests.
 func (t *Transport) CancelRequest(req *Request) {
        t.reqMu.Lock()
        cancel := t.reqCanceler[req]

diff --git a/src/net/http/transport_test.go b/src/net/http/transport_test.go
index 3b2a5f978e263557feca946c0f1af4eed838cf86..8cb89a4220b7ca554cca0b5f1cd95863d1cb79c9 100644 (file)
--- a/src/net/http/transport_test.go
+++ b/src/net/http/transport_test.go
@@ -2208,9 +2208,8 @@ func TestTransportTLSHandshakeTimeout(t *testing.T) {
 // Trying to repro golang.org/issue/3514
 func TestTLSServerClosesConnection(t *testing.T) {
        defer afterTest(t)
-       if runtime.GOOS == "windows" {
-               t.Skip("skipping flaky test on Windows; golang.org/issue/7634")
-       }
+       setFlaky(t, 7634)
+
        closedc := make(chan bool, 1)
        ts := httptest.NewTLSServer(HandlerFunc(func(w ResponseWriter, r *Request) {
                if strings.Contains(r.URL.Path, "/keep-alive-then-die") {

diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go
index 677a5f57fd48effb89d9ff5ecc6302d3325c375a..439496ac81d2620383c42df07cb7549d9e8299ec 100644 (file)
--- a/src/net/lookup_test.go
+++ b/src/net/lookup_test.go
@@ -441,8 +441,19 @@ func TestLookupDotsWithLocalSource(t *testing.T) {
                if i == 1 {
                        mode = "netcgo"
                }
-               for _, name := range names {
+       loop:
+               for i, name := range names {
                        if strings.Index(name, ".") == len(name)-1 { // "localhost" not "localhost."
+                               for j := range names {
+                                       if j == i {
+                                               continue
+                                       }
+                                       if names[j] == name[:len(name)-1] {
+                                               // It's OK if we find the name without the dot,
+                                               // as some systems say 127.0.0.1 localhost localhost.
+                                               continue loop
+                                       }
+                               }
                                t.Errorf("%s: got %s; want %s", mode, name, name[:len(name)-1])
                        } else if strings.Contains(name, ".") && !strings.HasSuffix(name, ".") { // "localhost.localdomain." not "localhost.localdomain"
                                t.Errorf("%s: got %s; want name ending with trailing dot", mode, name)
@@ -455,7 +466,7 @@ func TestLookupDotsWithRemoteSource(t *testing.T) {
        if testing.Short() && testenv.Builder() == "" || !*testExternal {
                t.Skip("avoid external network")
        }
-       if !supportsIPv4 || *testIPv4 {
+       if !supportsIPv4 || !*testIPv4 {
                t.Skip("IPv4 is required")
        }
 

diff --git a/src/net/net_test.go b/src/net/net_test.go
index 6dcfc2190e03c5675a75d5952f7a5fcefbe9fbcf..cd62b4373ebb1aafc66728432e19d808ba32672c 100644 (file)
--- a/src/net/net_test.go
+++ b/src/net/net_test.go
@@ -9,6 +9,7 @@ import (
        "os"
        "runtime"
        "testing"
+       "time"
 )
 
 func TestCloseRead(t *testing.T) {
@@ -209,6 +210,7 @@ func TestListenerClose(t *testing.T) {
                        defer os.Remove(ln.Addr().String())
                }
 
+               dst := ln.Addr().String()
                if err := ln.Close(); err != nil {
                        if perr := parseCloseError(err); perr != nil {
                                t.Error(perr)
@@ -222,9 +224,24 @@ func TestListenerClose(t *testing.T) {
                }
 
                if network == "tcp" {
-                       cc, err := Dial("tcp", ln.Addr().String())
+                       // We will have two TCP FSMs inside the
+                       // kernel here. There's no guarantee that a
+                       // signal comes from the far end FSM will be
+                       // delivered immediately to the near end FSM,
+                       // especially on the platforms that allow
+                       // multiple consumer threads to pull pending
+                       // established connections at the same time by
+                       // enabling SO_REUSEPORT option such as Linux,
+                       // DragonFly BSD. So we need to give some time
+                       // quantum to the kernel.
+                       //
+                       // Note that net.inet.tcp.reuseport_ext=1 by
+                       // default on DragonFly BSD.
+                       time.Sleep(time.Millisecond)
+
+                       cc, err := Dial("tcp", dst)
                        if err == nil {
-                               t.Error("Dial to closed TCP listener succeeeded.")
+                               t.Error("Dial to closed TCP listener succeeded.")
                                cc.Close()
                        }
                }
@@ -272,6 +289,9 @@ func TestListenCloseListen(t *testing.T) {
                }
                addr := ln.Addr().String()
                if err := ln.Close(); err != nil {
+                       if perr := parseCloseError(err); perr != nil {
+                               t.Error(perr)
+                       }
                        t.Fatal(err)
                }
                ln, err = Listen("tcp", addr)

diff --git a/src/net/net_windows_test.go b/src/net/net_windows_test.go
index e59dcd52d3dc7537afbbd85c4a94ec9214d7d8c2..095a339e02c8e69a8a258526733ee94d8a92bd1e 100644 (file)
--- a/src/net/net_windows_test.go
+++ b/src/net/net_windows_test.go
@@ -12,6 +12,7 @@ import (
        "io/ioutil"
        "os"
        "os/exec"
+       "regexp"
        "sort"
        "strings"
        "syscall"
@@ -374,14 +375,20 @@ func netshInterfaceIPv6ShowAddress(name string) ([]string, error) {
                }
                // remove scope ID if present
                f = bytes.Split(f[1], []byte{'%'})
+
+               // netsh can create IPv4-embedded IPv6 addresses, like fe80::5efe:192.168.140.1.
+               // Convert these to all hexadecimal fe80::5efe:c0a8:8c01 for later string comparisons.
+               ipv4Tail := regexp.MustCompile(`:\d+\.\d+\.\d+\.\d+$`)
+               if ipv4Tail.Match(f[0]) {
+                       f[0] = []byte(ParseIP(string(f[0])).String())
+               }
+
                addrs = append(addrs, string(bytes.ToLower(bytes.TrimSpace(f[0]))))
        }
        return addrs, nil
 }
 
 func TestInterfaceAddrsWithNetsh(t *testing.T) {
-       t.Skip("see https://golang.org/issue/13981")
-
        if isWindowsXP(t) {
                t.Skip("Windows XP netsh command does not provide required functionality")
        }
@@ -393,6 +400,10 @@ func TestInterfaceAddrsWithNetsh(t *testing.T) {
                t.Fatal(err)
        }
        for _, ifi := range ift {
+               // Skip the interface if it's down.
+               if (ifi.Flags & FlagUp) == 0 {
+                       continue
+               }
                have := make([]string, 0)
                addrs, err := ifi.Addrs()
                if err != nil {

diff --git a/src/net/url/url.go b/src/net/url/url.go
index 3ea75637ac5bd2bd909d81659a122fa18557c147..1a93e3496edb00446c0c667aff6ea66258c6344f 100644 (file)
--- a/src/net/url/url.go
+++ b/src/net/url/url.go
@@ -193,8 +193,9 @@ func unescape(s string, mode encoding) (string, error) {
                                // that are valid host name bytes in their unescaped form.
                                // That is, you can use escaping in the zone identifier but not
                                // to introduce bytes you couldn't just write directly.
+                               // But Windows puts spaces here! Yay.
                                v := unhex(s[i+1])<<4 | unhex(s[i+2])
-                               if s[i:i+3] != "%25" && shouldEscape(v, encodeHost) {
+                               if s[i:i+3] != "%25" && v != ' ' && shouldEscape(v, encodeHost) {
                                        return "", EscapeError(s[i : i+3])
                                }
                        }

diff --git a/src/net/url/url_test.go b/src/net/url/url_test.go
index c31b18980ed5b18332ee72d66205ab805f0ed74a..d3f8487bd7c0addb96f8e7329f98619308589540 100644 (file)
--- a/src/net/url/url_test.go
+++ b/src/net/url/url_test.go
@@ -531,6 +531,17 @@ var urltests = []URLTest{
                },
                "",
        },
+       // spaces in hosts are disallowed but escaped spaces in IPv6 scope IDs are grudgingly OK.
+       // This happens on Windows.
+       // golang.org/issue/14002
+       {
+               "tcp://[2020::2020:20:2020:2020%25Windows%20Loves%20Spaces]:2020",
+               &URL{
+                       Scheme: "tcp",
+                       Host:   "[2020::2020:20:2020:2020%Windows Loves Spaces]:2020",
+               },
+               "",
+       },
 }
 
 // more useful string for debugging than fmt's struct printer

diff --git a/src/os/doc.go b/src/os/doc.go
index 389a8eb14cb284db9a5190fda7dda7ab604ac2ed..869a28a8a4e56d1e34df58567ac17846e888b9f9 100644 (file)
--- a/src/os/doc.go
+++ b/src/os/doc.go
@@ -7,9 +7,13 @@ package os
 import "time"
 
 // FindProcess looks for a running process by its pid.
+//
 // The Process it returns can be used to obtain information
 // about the underlying operating system process.
-func FindProcess(pid int) (p *Process, err error) {
+//
+// On Unix systems, FindProcess always succeeds and returns a Process
+// for the given pid, regardless of whether the process exists.
+func FindProcess(pid int) (*Process, error) {
        return findProcess(pid)
 }
 

diff --git a/src/runtime/asm_amd64.s b/src/runtime/asm_amd64.s
index cac032c3703a9f69f9d575519ce3fce30de541a5..5094812a05416adb3a5e570b1cb880e125fd4fc4 100644 (file)
--- a/src/runtime/asm_amd64.s
+++ b/src/runtime/asm_amd64.s
@@ -1350,14 +1350,14 @@ hugeloop:
 hugeloop_avx2:
        CMPQ    BX, $64
        JB      bigloop_avx2
-       MOVHDU  (SI), X0
-       MOVHDU  (DI), X1
-       MOVHDU  32(SI), X2
-       MOVHDU  32(DI), X3
-       VPCMPEQB        X1, X0, X4
-       VPCMPEQB        X2, X3, X5
-       VPAND   X4, X5, X6
-       VPMOVMSKB X6, DX
+       VMOVDQU (SI), Y0
+       VMOVDQU (DI), Y1
+       VMOVDQU 32(SI), Y2
+       VMOVDQU 32(DI), Y3
+       VPCMPEQB        Y1, Y0, Y4
+       VPCMPEQB        Y2, Y3, Y5
+       VPAND   Y4, Y5, Y6
+       VPMOVMSKB Y6, DX
        ADDQ    $64, SI
        ADDQ    $64, DI
        SUBQ    $64, BX
@@ -1614,16 +1614,16 @@ big_loop:
        // Compare 64-bytes per loop iteration.
        // Loop is unrolled and uses AVX2.
 big_loop_avx2:
-       MOVHDU  (SI), X2
-       MOVHDU  (DI), X3
-       MOVHDU  32(SI), X4
-       MOVHDU  32(DI), X5
-       VPCMPEQB X2, X3, X0
-       VPMOVMSKB X0, AX
+       VMOVDQU (SI), Y2
+       VMOVDQU (DI), Y3
+       VMOVDQU 32(SI), Y4
+       VMOVDQU 32(DI), Y5
+       VPCMPEQB Y2, Y3, Y0
+       VPMOVMSKB Y0, AX
        XORL    $0xffffffff, AX
        JNE     diff32_avx2
-       VPCMPEQB X4, X5, X6
-       VPMOVMSKB X6, AX
+       VPCMPEQB Y4, Y5, Y6
+       VPMOVMSKB Y6, AX
        XORL    $0xffffffff, AX
        JNE     diff64_avx2
 
@@ -1908,26 +1908,26 @@ avx2:
        JNE no_avx2
        MOVD AX, X0
        LEAQ -32(SI)(BX*1), R11
-       VPBROADCASTB  X0, X1
+       VPBROADCASTB  X0, Y1
 avx2_loop:
-       MOVHDU (DI), X2
-       VPCMPEQB X1, X2, X3
-       VPTEST X3, X3
+       VMOVDQU (DI), Y2
+       VPCMPEQB Y1, Y2, Y3
+       VPTEST Y3, Y3
        JNZ avx2success
        ADDQ $32, DI
        CMPQ DI, R11
        JLT avx2_loop
        MOVQ R11, DI
-       MOVHDU (DI), X2
-       VPCMPEQB X1, X2, X3
-       VPTEST X3, X3
+       VMOVDQU (DI), Y2
+       VPCMPEQB Y1, Y2, Y3
+       VPTEST Y3, Y3
        JNZ avx2success
        VZEROUPPER
        MOVQ $-1, (R8)
        RET
 
 avx2success:
-       VPMOVMSKB X3, DX
+       VPMOVMSKB Y3, DX
        BSFL DX, DX
        SUBQ SI, DI
        ADDQ DI, DX

diff --git a/src/runtime/asm_arm.s b/src/runtime/asm_arm.s
index 09fbc952e09273a9baf6fad86076737128238907..07894a3a722d86accda3acb4bc674d1a1132f2d2 100644 (file)
--- a/src/runtime/asm_arm.s
+++ b/src/runtime/asm_arm.s
@@ -85,8 +85,12 @@ TEXT runtime·breakpoint(SB),NOSPLIT,$0-0
        // so you must manually "set $pc+=4" to skip it and continue.
 #ifdef GOOS_nacl
        WORD    $0xe125be7f     // BKPT 0x5bef, NACL_INSTR_ARM_BREAKPOINT
+#else
+#ifdef GOOS_plan9
+       WORD    $0xD1200070     // undefined instruction used as armv5 breakpoint in Plan 9
 #else
        WORD    $0xe7f001f0     // undefined instruction that gdb understands is a software breakpoint
+#endif
 #endif
        RET
 

diff --git a/src/runtime/cgo/gcc_android.c b/src/runtime/cgo/gcc_android.c
index be27725680a0aefbb3d815dae685682128ffe1bd..a3bc6c4d409c65d79df77791106cfd71306cff7a 100644 (file)
--- a/src/runtime/cgo/gcc_android.c
+++ b/src/runtime/cgo/gcc_android.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <stdarg.h>
 #include <android/log.h>
 #include "libcgo.h"

diff --git a/src/runtime/cgo/gcc_android_386.c b/src/runtime/cgo/gcc_android_386.c
index a82d7d01b0bb0dcc275e75226ea13d0c01793bed..db1d48aaaed549bc0ff16158f828c51cd695b446 100644 (file)
--- a/src/runtime/cgo/gcc_android_386.c
+++ b/src/runtime/cgo/gcc_android_386.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <string.h> /* for strerror */
 #include <pthread.h>
 #include <signal.h>

diff --git a/src/runtime/cgo/gcc_android_amd64.c b/src/runtime/cgo/gcc_android_amd64.c
index 4cea4597485e728a06cf3ec2ff0a733811ab8d4f..17d88cec9114e1f62f9ae5a92fa3fae1c0e8b5de 100644 (file)
--- a/src/runtime/cgo/gcc_android_amd64.c
+++ b/src/runtime/cgo/gcc_android_amd64.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <string.h> /* for strerror */
 #include <pthread.h>
 #include <signal.h>

diff --git a/src/runtime/cgo/gcc_android_arm.c b/src/runtime/cgo/gcc_android_arm.c
index 85cd244c02caba0589ddb36d41d38d3125118490..67cb5a895280abf1b533343b2e26b08b394479da 100644 (file)
--- a/src/runtime/cgo/gcc_android_arm.c
+++ b/src/runtime/cgo/gcc_android_arm.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <pthread.h>
 #include <signal.h>
 #include <stdio.h>

diff --git a/src/runtime/cgo/gcc_android_arm64.c b/src/runtime/cgo/gcc_android_arm64.c
index 5d4cefee6074df27dbaf26bbd6f0212fa024d872..acf37355eb1f81b638b868601eda4eb4b805735b 100644 (file)
--- a/src/runtime/cgo/gcc_android_arm64.c
+++ b/src/runtime/cgo/gcc_android_arm64.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <pthread.h>
 #include <signal.h>
 #include <stdio.h>

diff --git a/src/runtime/cgo/gcc_darwin_386.c b/src/runtime/cgo/gcc_darwin_386.c
index 6668ba4a2135781c3cc48d40ffb35839f5687a0f..a94e5ee48d0454223b59a1a7265e82a9f0c1346f 100644 (file)
--- a/src/runtime/cgo/gcc_darwin_386.c
+++ b/src/runtime/cgo/gcc_darwin_386.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <string.h> /* for strerror */
 #include <pthread.h>
 #include <signal.h>

diff --git a/src/runtime/cgo/gcc_darwin_amd64.c b/src/runtime/cgo/gcc_darwin_amd64.c
index dc679acab9d5caf94f3819901a41b3a8773c0f58..b70c83345f5f11beaee86fe5b31f40ab885d49fb 100644 (file)
--- a/src/runtime/cgo/gcc_darwin_amd64.c
+++ b/src/runtime/cgo/gcc_darwin_amd64.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <string.h> /* for strerror */
 #include <pthread.h>
 #include <signal.h>

diff --git a/src/runtime/cgo/gcc_darwin_arm.c b/src/runtime/cgo/gcc_darwin_arm.c
index c303b914ccb400b95721c3e822bf4e40d5505cb3..c0ce449f1346c9537a2c92229c4d64b0d8d1a407 100644 (file)
--- a/src/runtime/cgo/gcc_darwin_arm.c
+++ b/src/runtime/cgo/gcc_darwin_arm.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <limits.h>
 #include <pthread.h>
 #include <signal.h>

diff --git a/src/runtime/cgo/gcc_darwin_arm64.c b/src/runtime/cgo/gcc_darwin_arm64.c
index b64a063b982eb4464cf04e9f755c81fa6e7933e0..1ba00b02fb59b898c58827fcbf40e5be4293d5c7 100644 (file)
--- a/src/runtime/cgo/gcc_darwin_arm64.c
+++ b/src/runtime/cgo/gcc_darwin_arm64.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <limits.h>
 #include <pthread.h>
 #include <signal.h>

diff --git a/src/runtime/cgo/gcc_dragonfly_amd64.c b/src/runtime/cgo/gcc_dragonfly_amd64.c
index f79f652e466e5b4d4ca83a3966a63527e72979a7..9d02add92dfc7cd30b5885a81f0fd6698c63bc64 100644 (file)
--- a/src/runtime/cgo/gcc_dragonfly_amd64.c
+++ b/src/runtime/cgo/gcc_dragonfly_amd64.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <sys/types.h>
 #include <sys/signalvar.h>
 #include <pthread.h>
@@ -56,6 +58,7 @@ static void*
 threadentry(void *v)
 {
        ThreadStart ts;
+       stack_t ss;
 
        ts = *(ThreadStart*)v;
        free(v);
@@ -65,6 +68,17 @@ threadentry(void *v)
         */
        setg_gcc((void*)ts.g);
 
+       // On DragonFly, a new thread inherits the signal stack of the
+       // creating thread.  That confuses minit, so we remove that
+       // signal stack here before calling the regular mstart.  It's
+       // a bit baroque to remove a signal stack here only to add one
+       // in minit, but it's a simple change that keeps DragonFly
+       // working like other OS's.  At this point all signals are
+       // blocked, so there is no race.
+       memset(&ss, 0, sizeof ss);
+       ss.ss_flags = SS_DISABLE;
+       sigaltstack(&ss, nil);
+
        crosscall_amd64(ts.fn);
        return nil;
 }

diff --git a/src/runtime/cgo/gcc_fatalf.c b/src/runtime/cgo/gcc_fatalf.c
index 21c1acfaad18c34fa41259bc1578aed9c70e3452..c931b79abf3125a3e5c88aa25fa5e80780a8bc8e 100644 (file)
--- a/src/runtime/cgo/gcc_fatalf.c
+++ b/src/runtime/cgo/gcc_fatalf.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 // +build !android,linux
 
 #include <stdarg.h>

diff --git a/src/runtime/cgo/gcc_freebsd_386.c b/src/runtime/cgo/gcc_freebsd_386.c
index 074418f77d3dd35d678c9510caa1d13dfb84a585..2afdf2088fd3863ca671fa74df39a75ebb3a244a 100644 (file)
--- a/src/runtime/cgo/gcc_freebsd_386.c
+++ b/src/runtime/cgo/gcc_freebsd_386.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <sys/types.h>
 #include <sys/signalvar.h>
 #include <pthread.h>

diff --git a/src/runtime/cgo/gcc_freebsd_amd64.c b/src/runtime/cgo/gcc_freebsd_amd64.c
index f79f652e466e5b4d4ca83a3966a63527e72979a7..bf71d4c09d5009fc7f1866ca404a4764d1cb7a04 100644 (file)
--- a/src/runtime/cgo/gcc_freebsd_amd64.c
+++ b/src/runtime/cgo/gcc_freebsd_amd64.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <sys/types.h>
 #include <sys/signalvar.h>
 #include <pthread.h>

diff --git a/src/runtime/cgo/gcc_freebsd_arm.c b/src/runtime/cgo/gcc_freebsd_arm.c
index 2a86a91174ed209016142f68d2d40f88b29e6e05..60bca55d84b0331852aa1b0bf23dd7108bad4dde 100644 (file)
--- a/src/runtime/cgo/gcc_freebsd_arm.c
+++ b/src/runtime/cgo/gcc_freebsd_arm.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <sys/types.h>
 #include <machine/sysarch.h>
 #include <sys/signalvar.h>

diff --git a/src/runtime/cgo/gcc_libinit.c b/src/runtime/cgo/gcc_libinit.c
index c3e94f58d2c902c3652cd58a3a840e496074637f..5b9558aabc8350bb0bb41fdb73b94cfd133a5f3d 100644 (file)
--- a/src/runtime/cgo/gcc_libinit.c
+++ b/src/runtime/cgo/gcc_libinit.c
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
 // +build darwin dragonfly freebsd linux netbsd solaris
 // +build !ppc64,!ppc64le
 

diff --git a/src/runtime/cgo/gcc_libinit_linux_ppc64x.c b/src/runtime/cgo/gcc_libinit_linux_ppc64x.c
index 82413a5a65ebbddb7b885ca02222030dc4dd3a69..18ccf935727459d6b670033471fa2e7a463b3daf 100644 (file)
--- a/src/runtime/cgo/gcc_libinit_linux_ppc64x.c
+++ b/src/runtime/cgo/gcc_libinit_linux_ppc64x.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 // TODO: see issue #10410
 // +build linux
 // +build ppc64 ppc64le

diff --git a/src/runtime/cgo/gcc_libinit_openbsd.c b/src/runtime/cgo/gcc_libinit_openbsd.c
index 7e5b6468a6fde5043a14542b5562e7c190cd8e64..13904eede21faa92d01adca3873c25e6fbb97ab0 100644 (file)
--- a/src/runtime/cgo/gcc_libinit_openbsd.c
+++ b/src/runtime/cgo/gcc_libinit_openbsd.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <stdio.h>
 #include <stdlib.h>
 

diff --git a/src/runtime/cgo/gcc_libinit_windows.c b/src/runtime/cgo/gcc_libinit_windows.c
index 7e5b6468a6fde5043a14542b5562e7c190cd8e64..13904eede21faa92d01adca3873c25e6fbb97ab0 100644 (file)
--- a/src/runtime/cgo/gcc_libinit_windows.c
+++ b/src/runtime/cgo/gcc_libinit_windows.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <stdio.h>
 #include <stdlib.h>
 

diff --git a/src/runtime/cgo/gcc_linux_386.c b/src/runtime/cgo/gcc_linux_386.c
index 8fb7130e31b01d37c5e7896775def5edd315ac28..2457eb3806301ba77ac5f6df9755b3201d50ad24 100644 (file)
--- a/src/runtime/cgo/gcc_linux_386.c
+++ b/src/runtime/cgo/gcc_linux_386.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <pthread.h>
 #include <string.h>
 #include <signal.h>

diff --git a/src/runtime/cgo/gcc_linux_amd64.c b/src/runtime/cgo/gcc_linux_amd64.c
index 51ca6446cf1a55a999971f5b0fe5554c47cbcb59..5113a769b5fc2eb6dce85399b0f919b90a441840 100644 (file)
--- a/src/runtime/cgo/gcc_linux_amd64.c
+++ b/src/runtime/cgo/gcc_linux_amd64.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <pthread.h>
 #include <errno.h>
 #include <string.h> // strerror

diff --git a/src/runtime/cgo/gcc_linux_arm.c b/src/runtime/cgo/gcc_linux_arm.c
index 7d4b4d6d4f404c71dc542bad77ab4c95d9df165c..ce940fee4553d65eff7a9ffeacc89f9e24a1c8f9 100644 (file)
--- a/src/runtime/cgo/gcc_linux_arm.c
+++ b/src/runtime/cgo/gcc_linux_arm.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <pthread.h>
 #include <string.h>
 #include <signal.h>

diff --git a/src/runtime/cgo/gcc_linux_arm64.c b/src/runtime/cgo/gcc_linux_arm64.c
index ea11cf531315162494961bb5799cf363c7e3fa58..babbd50e85f5f38b2e61dbd644d75995afb7afb9 100644 (file)
--- a/src/runtime/cgo/gcc_linux_arm64.c
+++ b/src/runtime/cgo/gcc_linux_arm64.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <pthread.h>
 #include <string.h>
 #include <signal.h>

diff --git a/src/runtime/cgo/gcc_linux_ppc64x.c b/src/runtime/cgo/gcc_linux_ppc64x.c
index b1762957a2e07d86ad6a9699126eb3dddfdd12db..1264ab5959670f3050fc0df4b3074914f597b4e8 100644 (file)
--- a/src/runtime/cgo/gcc_linux_ppc64x.c
+++ b/src/runtime/cgo/gcc_linux_ppc64x.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 // +build ppc64 ppc64le
 
 #include <pthread.h>

diff --git a/src/runtime/cgo/gcc_mmap.c b/src/runtime/cgo/gcc_mmap.c
index 10d589fa288cddc51cc9ec4420377f06e1dc7351..f2bcc9866b2293a1dfb644711b274f59a49086b7 100644 (file)
--- a/src/runtime/cgo/gcc_mmap.c
+++ b/src/runtime/cgo/gcc_mmap.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 // +build linux,amd64
 
 #include <errno.h>

diff --git a/src/runtime/cgo/gcc_netbsd_386.c b/src/runtime/cgo/gcc_netbsd_386.c
index 2505e6dc7cf87e407326792b65e34a1d61eef31e..4355bd0cae30393b5a5c982a400567130fbf3455 100644 (file)
--- a/src/runtime/cgo/gcc_netbsd_386.c
+++ b/src/runtime/cgo/gcc_netbsd_386.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <sys/types.h>
 #include <pthread.h>
 #include <signal.h>
@@ -55,6 +57,7 @@ static void*
 threadentry(void *v)
 {
        ThreadStart ts;
+       stack_t ss;
 
        ts = *(ThreadStart*)v;
        free(v);
@@ -64,6 +67,17 @@ threadentry(void *v)
         */
        setg_gcc((void*)ts.g);
 
+       // On NetBSD, a new thread inherits the signal stack of the
+       // creating thread.  That confuses minit, so we remove that
+       // signal stack here before calling the regular mstart.  It's
+       // a bit baroque to remove a signal stack here only to add one
+       // in minit, but it's a simple change that keeps NetBSD
+       // working like other OS's.  At this point all signals are
+       // blocked, so there is no race.
+       memset(&ss, 0, sizeof ss);
+       ss.ss_flags = SS_DISABLE;
+       sigaltstack(&ss, nil);
+
        crosscall_386(ts.fn);
        return nil;
 }

diff --git a/src/runtime/cgo/gcc_netbsd_amd64.c b/src/runtime/cgo/gcc_netbsd_amd64.c
index 8f646502d7a2269c36de14a9b1a20ad0d62b4566..00e0667dbe3fd1b7c793983b47b72bd090b69561 100644 (file)
--- a/src/runtime/cgo/gcc_netbsd_amd64.c
+++ b/src/runtime/cgo/gcc_netbsd_amd64.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <sys/types.h>
 #include <pthread.h>
 #include <signal.h>
@@ -56,6 +58,7 @@ static void*
 threadentry(void *v)
 {
        ThreadStart ts;
+       stack_t ss;
 
        ts = *(ThreadStart*)v;
        free(v);
@@ -65,6 +68,17 @@ threadentry(void *v)
         */
        setg_gcc((void*)ts.g);
 
+       // On NetBSD, a new thread inherits the signal stack of the
+       // creating thread.  That confuses minit, so we remove that
+       // signal stack here before calling the regular mstart.  It's
+       // a bit baroque to remove a signal stack here only to add one
+       // in minit, but it's a simple change that keeps NetBSD
+       // working like other OS's.  At this point all signals are
+       // blocked, so there is no race.
+       memset(&ss, 0, sizeof ss);
+       ss.ss_flags = SS_DISABLE;
+       sigaltstack(&ss, nil);
+
        crosscall_amd64(ts.fn);
        return nil;
 }

diff --git a/src/runtime/cgo/gcc_netbsd_arm.c b/src/runtime/cgo/gcc_netbsd_arm.c
index 7a98c0de24bdfc7cf4fd94c6000f942c5f520f8d..32bc85b7c64da905ad6a08fc9ac231443b146287 100644 (file)
--- a/src/runtime/cgo/gcc_netbsd_arm.c
+++ b/src/runtime/cgo/gcc_netbsd_arm.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <sys/types.h>
 #include <pthread.h>
 #include <signal.h>
@@ -57,10 +59,22 @@ static void*
 threadentry(void *v)
 {
        ThreadStart ts;
+       stack_t ss;
 
        ts = *(ThreadStart*)v;
        free(v);
 
+       // On NetBSD, a new thread inherits the signal stack of the
+       // creating thread.  That confuses minit, so we remove that
+       // signal stack here before calling the regular mstart.  It's
+       // a bit baroque to remove a signal stack here only to add one
+       // in minit, but it's a simple change that keeps NetBSD
+       // working like other OS's.  At this point all signals are
+       // blocked, so there is no race.
+       memset(&ss, 0, sizeof ss);
+       ss.ss_flags = SS_DISABLE;
+       sigaltstack(&ss, nil);
+
        crosscall_arm1(ts.fn, setg_gcc, (void*)ts.g);
        return nil;
 }

diff --git a/src/runtime/cgo/gcc_openbsd_386.c b/src/runtime/cgo/gcc_openbsd_386.c
index c4be9a00969e57332020048f351e47d2b400a992..5f6d4cbb93620b5cf3fbec4ce76d01f795d7e3df 100644 (file)
--- a/src/runtime/cgo/gcc_openbsd_386.c
+++ b/src/runtime/cgo/gcc_openbsd_386.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <sys/types.h>
 #include <dlfcn.h>
 #include <errno.h>

diff --git a/src/runtime/cgo/gcc_openbsd_amd64.c b/src/runtime/cgo/gcc_openbsd_amd64.c
index 8522cd48c4ac9fec18e06c53fe850ef91da4d6dc..42265671d7d55fd3b62a5d7c62e75452a67aeaff 100644 (file)
--- a/src/runtime/cgo/gcc_openbsd_amd64.c
+++ b/src/runtime/cgo/gcc_openbsd_amd64.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <sys/types.h>
 #include <dlfcn.h>
 #include <errno.h>

diff --git a/src/runtime/cgo/gcc_setenv.c b/src/runtime/cgo/gcc_setenv.c
index ca29dcb05f2040cde508f766e2432c85ea0e1947..c976ac3d37c4e6addf3864748a96484003e60a86 100644 (file)
--- a/src/runtime/cgo/gcc_setenv.c
+++ b/src/runtime/cgo/gcc_setenv.c
@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
 // +build darwin dragonfly freebsd linux netbsd openbsd solaris
 
 #include "libcgo.h"

diff --git a/src/runtime/cgo/gcc_signal_darwin_armx.c b/src/runtime/cgo/gcc_signal_darwin_armx.c
index e36fe26bb1041fcfe006314e12d5d7b583e16dbd..295c5623f0709b1a97779ee5e5294d26ea9d45b1 100644 (file)
--- a/src/runtime/cgo/gcc_signal_darwin_armx.c
+++ b/src/runtime/cgo/gcc_signal_darwin_armx.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 // Emulation of the Unix signal SIGSEGV.
 //
 // On iOS, Go tests and apps under development are run by lldb.

diff --git a/src/runtime/cgo/gcc_signal_darwin_lldb.c b/src/runtime/cgo/gcc_signal_darwin_lldb.c
index b26315f10d7a22b9461092c7e1f01db025e429ad..edb55f3030da3d1f97093c2751aa0dba67f0d964 100644 (file)
--- a/src/runtime/cgo/gcc_signal_darwin_lldb.c
+++ b/src/runtime/cgo/gcc_signal_darwin_lldb.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 // +build !lldb
 // +build darwin
 // +build arm arm64

diff --git a/src/runtime/cgo/gcc_solaris_amd64.c b/src/runtime/cgo/gcc_solaris_amd64.c
index 98a1a8be532a3bf9cebee1f86adf14bdb64f9b72..5a01e0826e330ca5992fd1253f1bab411b18f9e8 100644 (file)
--- a/src/runtime/cgo/gcc_solaris_amd64.c
+++ b/src/runtime/cgo/gcc_solaris_amd64.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include <pthread.h>
 #include <string.h>
 #include <signal.h>

diff --git a/src/runtime/cgo/gcc_util.c b/src/runtime/cgo/gcc_util.c
index 143734e94b09b1fac40ebd517c9309cfe5704d8d..d5efec396bd36bf58afce817cdd49dc754c5c465 100644 (file)
--- a/src/runtime/cgo/gcc_util.c
+++ b/src/runtime/cgo/gcc_util.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #include "libcgo.h"
 
 /* Stub for calling malloc from Go */

diff --git a/src/runtime/cgo/gcc_windows_386.c b/src/runtime/cgo/gcc_windows_386.c
index acd038ccd6fc8afc5463b3bced1dd13713b8b632..e02991af2186661de6d0828cb7af17136ef9abbf 100644 (file)
--- a/src/runtime/cgo/gcc_windows_386.c
+++ b/src/runtime/cgo/gcc_windows_386.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #define WIN32_LEAN_AND_MEAN
 #include <windows.h>
 #include <process.h>

diff --git a/src/runtime/cgo/gcc_windows_amd64.c b/src/runtime/cgo/gcc_windows_amd64.c
index ce7e06b3dfe3e78f0b127410ed0c662401a6d53e..1b3e8e32836de3d66a9c2f1206cf3fb31b564204 100644 (file)
--- a/src/runtime/cgo/gcc_windows_amd64.c
+++ b/src/runtime/cgo/gcc_windows_amd64.c
@@ -2,6 +2,8 @@
 // Use of this source code is governed by a BSD-style
 // license that can be found in the LICENSE file.
 
+// +build cgo
+
 #define WIN64_LEAN_AND_MEAN
 #include <windows.h>
 #include <process.h>

diff --git a/src/runtime/cgo_mmap.go b/src/runtime/cgo_mmap.go
index ef5501ca5f7ad5ea3d93c341400ff10b62eda8e9..c0396bdde51b84ad4eecd410345d84bd2b4e47e9 100644 (file)
--- a/src/runtime/cgo_mmap.go
+++ b/src/runtime/cgo_mmap.go
@@ -15,12 +15,19 @@ import "unsafe"
 //go:linkname _cgo_mmap _cgo_mmap
 var _cgo_mmap unsafe.Pointer
 
-func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) (ret unsafe.Pointer) {
+func mmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) unsafe.Pointer {
        if _cgo_mmap != nil {
+               // Make ret a uintptr so that writing to it in the
+               // function literal does not trigger a write barrier.
+               // A write barrier here could break because of the way
+               // that mmap uses the same value both as a pointer and
+               // an errno value.
+               // TODO: Fix mmap to return two values.
+               var ret uintptr
                systemstack(func() {
                        ret = callCgoMmap(addr, n, prot, flags, fd, off)
                })
-               return
+               return unsafe.Pointer(ret)
        }
        return sysMmap(addr, n, prot, flags, fd, off)
 }
@@ -31,4 +38,4 @@ func sysMmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32)
 // cgoMmap calls the mmap function in the runtime/cgo package on the
 // callCgoMmap calls the mmap function in the runtime/cgo package
 // using the GCC calling convention.  It is implemented in assembly.
-func callCgoMmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) unsafe.Pointer
+func callCgoMmap(addr unsafe.Pointer, n uintptr, prot, flags, fd int32, off uint32) uintptr

diff --git a/src/runtime/cgocall.go b/src/runtime/cgocall.go
index 210d1862f95f8c7548f7ff7f95fbe2bc023e26c9..66115fd8b49bd01ad915a891040427e5a4cc1b95 100644 (file)
--- a/src/runtime/cgocall.go
+++ b/src/runtime/cgocall.go
@@ -467,6 +467,14 @@ func cgoCheckArg(t *_type, p unsafe.Pointer, indir, top bool, msg string) {
                        cgoCheckArg(st.elem, p, true, false, msg)
                        p = add(p, st.elem.size)
                }
+       case kindString:
+               ss := (*stringStruct)(p)
+               if !cgoIsGoPointer(ss.str) {
+                       return
+               }
+               if !top {
+                       panic(errorString(msg))
+               }
        case kindStruct:
                st := (*structtype)(unsafe.Pointer(t))
                if !indir {

diff --git a/src/runtime/crash_unix_test.go b/src/runtime/crash_unix_test.go
index a7af7eff285efe40b401bd3f15672940a26c3546..1a012eb6ef15c95afc9580639b29c0b7c6be7d37 100644 (file)
--- a/src/runtime/crash_unix_test.go
+++ b/src/runtime/crash_unix_test.go
@@ -136,6 +136,10 @@ func loop(i int, c chan bool) {
 
 func TestSignalExitStatus(t *testing.T) {
        testenv.MustHaveGoBuild(t)
+       switch runtime.GOOS {
+       case "netbsd", "solaris":
+               t.Skipf("skipping on %s; see https://golang.org/issue/14063", runtime.GOOS)
+       }
        exe, err := buildTestProg(t, "testprog")
        if err != nil {
                t.Fatal(err)

diff --git a/src/runtime/heapdump.go b/src/runtime/heapdump.go
index dfceba337659533ca3ba868c9c16a9cdab487018..4d1da1c1dfbb61eba27fd895c042061cd373bed6 100644 (file)
--- a/src/runtime/heapdump.go
+++ b/src/runtime/heapdump.go
@@ -639,7 +639,7 @@ func dumpmemprof() {
        }
 }
 
-var dumphdr = []byte("go1.5 heap dump\n")
+var dumphdr = []byte("go1.6 heap dump\n")
 
 func mdump() {
        // make sure we're done sweeping

diff --git a/src/runtime/malloc.go b/src/runtime/malloc.go
index 18001bf85ec64c383ebb563795db8ae25907d687..b520c68df0810c230ced3e68338420eec6a1fcb4 100644 (file)
--- a/src/runtime/malloc.go
+++ b/src/runtime/malloc.go
@@ -455,7 +455,11 @@ func (h *mheap) sysAlloc(n uintptr) unsafe.Pointer {
        }
 
        if p < h.arena_start || uintptr(p)+p_size-h.arena_start >= _MaxArena32 {
-               print("runtime: memory allocated by OS (", hex(p), ") not in usable range [", hex(h.arena_start), ",", hex(h.arena_start+_MaxArena32), ")\n")
+               top := ^uintptr(0)
+               if top-h.arena_start > _MaxArena32 {
+                       top = h.arena_start + _MaxArena32
+               }
+               print("runtime: memory allocated by OS (", hex(p), ") not in usable range [", hex(h.arena_start), ",", hex(top), ")\n")
                sysFree(unsafe.Pointer(p), p_size, &memstats.heap_sys)
                return nil
        }

diff --git a/src/runtime/memclr_amd64.s b/src/runtime/memclr_amd64.s
index 5e78037df605c122b9c3593697efbee8e73cacf3..c257d59b30b85d9fd3971e934721cbe392d550d2 100644 (file)
--- a/src/runtime/memclr_amd64.s
+++ b/src/runtime/memclr_amd64.s
@@ -65,40 +65,40 @@ loop:
        JMP     tail
 
 loop_preheader_avx2:
-       VPXOR X0, X0, X0
+       VPXOR Y0, Y0, Y0
        // For smaller sizes MOVNTDQ may be faster or slower depending on hardware.
        // For larger sizes it is always faster, even on dual Xeons with 30M cache.
        // TODO take into account actual LLC size. E. g. glibc uses LLC size/2.
        CMPQ    BX, $0x2000000
        JAE     loop_preheader_avx2_huge
 loop_avx2:
-       MOVHDU  X0, 0(DI)
-       MOVHDU  X0, 32(DI)
-       MOVHDU  X0, 64(DI)
-       MOVHDU  X0, 96(DI)
+       VMOVDQU Y0, 0(DI)
+       VMOVDQU Y0, 32(DI)
+       VMOVDQU Y0, 64(DI)
+       VMOVDQU Y0, 96(DI)
        SUBQ    $128, BX
        ADDQ    $128, DI
        CMPQ    BX, $128
        JAE     loop_avx2
-       MOVHDU  X0, -32(DI)(BX*1)
-       MOVHDU  X0, -64(DI)(BX*1)
-       MOVHDU  X0, -96(DI)(BX*1)
-       MOVHDU  X0, -128(DI)(BX*1)
+       VMOVDQU  Y0, -32(DI)(BX*1)
+       VMOVDQU  Y0, -64(DI)(BX*1)
+       VMOVDQU  Y0, -96(DI)(BX*1)
+       VMOVDQU  Y0, -128(DI)(BX*1)
        VZEROUPPER
        RET
 loop_preheader_avx2_huge:
        // Align to 32 byte boundary
-       MOVHDU  X0, 0(DI)
+       VMOVDQU  Y0, 0(DI)
        MOVQ    DI, SI
        ADDQ    $32, DI
        ANDQ    $~31, DI
        SUBQ    DI, SI
        ADDQ    SI, BX
 loop_avx2_huge:
-       MOVNTHD X0, 0(DI)
-       MOVNTHD X0, 32(DI)
-       MOVNTHD X0, 64(DI)
-       MOVNTHD X0, 96(DI)
+       VMOVNTDQ        Y0, 0(DI)
+       VMOVNTDQ        Y0, 32(DI)
+       VMOVNTDQ        Y0, 64(DI)
+       VMOVNTDQ        Y0, 96(DI)
        SUBQ    $128, BX
        ADDQ    $128, DI
        CMPQ    BX, $128
@@ -108,10 +108,10 @@ loop_avx2_huge:
        // should be used in conjunction with MOVNTDQ instructions..."
        // [1] 64-ia-32-architectures-software-developer-manual-325462.pdf
        SFENCE
-       MOVHDU  X0, -32(DI)(BX*1)
-       MOVHDU  X0, -64(DI)(BX*1)
-       MOVHDU  X0, -96(DI)(BX*1)
-       MOVHDU  X0, -128(DI)(BX*1)
+       VMOVDQU  Y0, -32(DI)(BX*1)
+       VMOVDQU  Y0, -64(DI)(BX*1)
+       VMOVDQU  Y0, -96(DI)(BX*1)
+       VMOVDQU  Y0, -128(DI)(BX*1)
        VZEROUPPER
        RET
 

diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go
index 92b811830c37e65f14bd055070cdc76ff298d11a..94301c6dc7f0deb7aa91095dbeb367e9c432a55c 100644 (file)
--- a/src/runtime/mgc.go
+++ b/src/runtime/mgc.go
@@ -629,7 +629,7 @@ func (c *gcControllerState) findRunnableGCWorker(_p_ *p) *g {
        if gcBlackenEnabled == 0 {
                throw("gcControllerState.findRunnable: blackening not enabled")
        }
-       if _p_.gcBgMarkWorker == nil {
+       if _p_.gcBgMarkWorker == 0 {
                // The mark worker associated with this P is blocked
                // performing a mark transition. We can't run it
                // because it may be on some other run or wait queue.
@@ -711,7 +711,7 @@ func (c *gcControllerState) findRunnableGCWorker(_p_ *p) *g {
        }
 
        // Run the background mark worker
-       gp := _p_.gcBgMarkWorker
+       gp := _p_.gcBgMarkWorker.ptr()
        casgstatus(gp, _Gwaiting, _Grunnable)
        if trace.enabled {
                traceGoUnpark(gp, 0)
@@ -1325,7 +1325,7 @@ func gcBgMarkStartWorkers() {
                if p == nil || p.status == _Pdead {
                        break
                }
-               if p.gcBgMarkWorker == nil {
+               if p.gcBgMarkWorker == 0 {
                        go gcBgMarkWorker(p)
                        notetsleepg(&work.bgMarkReady, -1)
                        noteclear(&work.bgMarkReady)
@@ -1349,15 +1349,17 @@ func gcBgMarkPrepare() {
        work.nwait = ^uint32(0)
 }
 
-func gcBgMarkWorker(p *p) {
-       // Register this G as the background mark worker for p.
-       casgp := func(gpp **g, old, new *g) bool {
-               return casp((*unsafe.Pointer)(unsafe.Pointer(gpp)), unsafe.Pointer(old), unsafe.Pointer(new))
+func gcBgMarkWorker(_p_ *p) {
+       type parkInfo struct {
+               m      *m // Release this m on park.
+               attach *p // If non-nil, attach to this p on park.
        }
+       var park parkInfo
 
        gp := getg()
-       mp := acquirem()
-       owned := casgp(&p.gcBgMarkWorker, nil, gp)
+       park.m = acquirem()
+       park.attach = _p_
+       // Inform gcBgMarkStartWorkers that this worker is ready.
        // After this point, the background mark worker is scheduled
        // cooperatively by gcController.findRunnable. Hence, it must
        // never be preempted, as this would put it into _Grunnable
@@ -1365,33 +1367,51 @@ func gcBgMarkWorker(p *p) {
        // is set, this puts itself into _Gwaiting to be woken up by
        // gcController.findRunnable at the appropriate time.
        notewakeup(&work.bgMarkReady)
-       if !owned {
-               // A sleeping worker came back and reassociated with
-               // the P. That's fine.
-               releasem(mp)
-               return
-       }
 
        for {
                // Go to sleep until woken by gcContoller.findRunnable.
                // We can't releasem yet since even the call to gopark
                // may be preempted.
-               gopark(func(g *g, mp unsafe.Pointer) bool {
-                       releasem((*m)(mp))
+               gopark(func(g *g, parkp unsafe.Pointer) bool {
+                       park := (*parkInfo)(parkp)
+
+                       // The worker G is no longer running, so it's
+                       // now safe to allow preemption.
+                       releasem(park.m)
+
+                       // If the worker isn't attached to its P,
+                       // attach now. During initialization and after
+                       // a phase change, the worker may have been
+                       // running on a different P. As soon as we
+                       // attach, the owner P may schedule the
+                       // worker, so this must be done after the G is
+                       // stopped.
+                       if park.attach != nil {
+                               p := park.attach
+                               park.attach = nil
+                               // cas the worker because we may be
+                               // racing with a new worker starting
+                               // on this P.
+                               if !p.gcBgMarkWorker.cas(0, guintptr(unsafe.Pointer(g))) {
+                                       // The P got a new worker.
+                                       // Exit this worker.
+                                       return false
+                               }
+                       }
                        return true
-               }, unsafe.Pointer(mp), "GC worker (idle)", traceEvGoBlock, 0)
+               }, noescape(unsafe.Pointer(&park)), "GC worker (idle)", traceEvGoBlock, 0)
 
                // Loop until the P dies and disassociates this
-               // worker. (The P may later be reused, in which case
-               // it will get a new worker.)
-               if p.gcBgMarkWorker != gp {
+               // worker (the P may later be reused, in which case
+               // it will get a new worker) or we failed to associate.
+               if _p_.gcBgMarkWorker.ptr() != gp {
                        break
                }
 
                // Disable preemption so we can use the gcw. If the
                // scheduler wants to preempt us, we'll stop draining,
                // dispose the gcw, and then preempt.
-               mp = acquirem()
+               park.m = acquirem()
 
                if gcBlackenEnabled == 0 {
                        throw("gcBgMarkWorker: blackening not enabled")
@@ -1405,13 +1425,13 @@ func gcBgMarkWorker(p *p) {
                        throw("work.nwait was > work.nproc")
                }
 
-               switch p.gcMarkWorkerMode {
+               switch _p_.gcMarkWorkerMode {
                default:
                        throw("gcBgMarkWorker: unexpected gcMarkWorkerMode")
                case gcMarkWorkerDedicatedMode:
-                       gcDrain(&p.gcw, gcDrainNoBlock|gcDrainFlushBgCredit)
+                       gcDrain(&_p_.gcw, gcDrainNoBlock|gcDrainFlushBgCredit)
                case gcMarkWorkerFractionalMode, gcMarkWorkerIdleMode:
-                       gcDrain(&p.gcw, gcDrainUntilPreempt|gcDrainFlushBgCredit)
+                       gcDrain(&_p_.gcw, gcDrainUntilPreempt|gcDrainFlushBgCredit)
                }
 
                // If we are nearing the end of mark, dispose
@@ -1421,12 +1441,12 @@ func gcBgMarkWorker(p *p) {
                // no workers and no work while we have this
                // cached, and before we compute done.
                if gcBlackenPromptly {
-                       p.gcw.dispose()
+                       _p_.gcw.dispose()
                }
 
                // Account for time.
                duration := nanotime() - startTime
-               switch p.gcMarkWorkerMode {
+               switch _p_.gcMarkWorkerMode {
                case gcMarkWorkerDedicatedMode:
                        atomic.Xaddint64(&gcController.dedicatedMarkTime, duration)
                        atomic.Xaddint64(&gcController.dedicatedMarkWorkersNeeded, 1)
@@ -1441,7 +1461,7 @@ func gcBgMarkWorker(p *p) {
                // of work?
                incnwait := atomic.Xadd(&work.nwait, +1)
                if incnwait > work.nproc {
-                       println("runtime: p.gcMarkWorkerMode=", p.gcMarkWorkerMode,
+                       println("runtime: p.gcMarkWorkerMode=", _p_.gcMarkWorkerMode,
                                "work.nwait=", incnwait, "work.nproc=", work.nproc)
                        throw("work.nwait > work.nproc")
                }
@@ -1453,21 +1473,19 @@ func gcBgMarkWorker(p *p) {
                        // as the worker for this P so
                        // findRunnableGCWorker doesn't try to
                        // schedule it.
-                       p.gcBgMarkWorker = nil
-                       releasem(mp)
+                       _p_.gcBgMarkWorker.set(nil)
+                       releasem(park.m)
 
                        gcMarkDone()
 
-                       // Disable preemption and reassociate with the P.
+                       // Disable preemption and prepare to reattach
+                       // to the P.
                        //
                        // We may be running on a different P at this
-                       // point, so this has to be done carefully.
-                       mp = acquirem()
-                       if !casgp(&p.gcBgMarkWorker, nil, gp) {
-                               // The P got a new worker.
-                               releasem(mp)
-                               break
-                       }
+                       // point, so we can't reattach until this G is
+                       // parked.
+                       park.m = acquirem()
+                       park.attach = _p_
                }
        }
 }

diff --git a/src/runtime/mprof.go b/src/runtime/mprof.go
index eb7231aec22142d05abf28c80ce6367010b836ab..fc73bbfbe1531a51051a7b59e310d1739340f74e 100644 (file)
--- a/src/runtime/mprof.go
+++ b/src/runtime/mprof.go
@@ -522,34 +522,51 @@ func ThreadCreateProfile(p []StackRecord) (n int, ok bool) {
 // Most clients should use the runtime/pprof package instead
 // of calling GoroutineProfile directly.
 func GoroutineProfile(p []StackRecord) (n int, ok bool) {
+       gp := getg()
+
+       isOK := func(gp1 *g) bool {
+               // Checking isSystemGoroutine here makes GoroutineProfile
+               // consistent with both NumGoroutine and Stack.
+               return gp1 != gp && readgstatus(gp1) != _Gdead && !isSystemGoroutine(gp1)
+       }
+
+       stopTheWorld("profile")
+
+       n = 1
+       for _, gp1 := range allgs {
+               if isOK(gp1) {
+                       n++
+               }
+       }
 
-       n = NumGoroutine()
        if n <= len(p) {
-               gp := getg()
-               stopTheWorld("profile")
-
-               n = NumGoroutine()
-               if n <= len(p) {
-                       ok = true
-                       r := p
-                       sp := getcallersp(unsafe.Pointer(&p))
-                       pc := getcallerpc(unsafe.Pointer(&p))
-                       systemstack(func() {
-                               saveg(pc, sp, gp, &r[0])
-                       })
-                       r = r[1:]
-                       for _, gp1 := range allgs {
-                               if gp1 == gp || readgstatus(gp1) == _Gdead {
-                                       continue
+               ok = true
+               r := p
+
+               // Save current goroutine.
+               sp := getcallersp(unsafe.Pointer(&p))
+               pc := getcallerpc(unsafe.Pointer(&p))
+               systemstack(func() {
+                       saveg(pc, sp, gp, &r[0])
+               })
+               r = r[1:]
+
+               // Save other goroutines.
+               for _, gp1 := range allgs {
+                       if isOK(gp1) {
+                               if len(r) == 0 {
+                                       // Should be impossible, but better to return a
+                                       // truncated profile than to crash the entire process.
+                                       break
                                }
                                saveg(^uintptr(0), ^uintptr(0), gp1, &r[0])
                                r = r[1:]
                        }
                }
-
-               startTheWorld()
        }
 
+       startTheWorld()
+
        return n, ok
 }
 

diff --git a/src/runtime/os1_darwin.go b/src/runtime/os1_darwin.go
index e9e0b6aa1cebb67e3015807161a7a4233a4f72fa..5c00407b2fcbb774a1cfd8df4e1ec802a03dcc95 100644 (file)
--- a/src/runtime/os1_darwin.go
+++ b/src/runtime/os1_darwin.go
@@ -162,20 +162,25 @@ func minit() {
        // Initialize signal handling.
        _g_ := getg()
 
-       var st stackt
-       sigaltstack(nil, &st)
-       if st.ss_flags&_SS_DISABLE != 0 {
-               signalstack(&_g_.m.gsignal.stack)
-               _g_.m.newSigstack = true
-       } else {
-               // Use existing signal stack.
-               stsp := uintptr(unsafe.Pointer(st.ss_sp))
-               _g_.m.gsignal.stack.lo = stsp
-               _g_.m.gsignal.stack.hi = stsp + st.ss_size
-               _g_.m.gsignal.stackguard0 = stsp + _StackGuard
-               _g_.m.gsignal.stackguard1 = stsp + _StackGuard
-               _g_.m.gsignal.stackAlloc = st.ss_size
-               _g_.m.newSigstack = false
+       // The alternate signal stack is buggy on arm and arm64.
+       // The signal handler handles it directly.
+       // The sigaltstack assembly function does nothing.
+       if GOARCH != "arm" && GOARCH != "arm64" {
+               var st stackt
+               sigaltstack(nil, &st)
+               if st.ss_flags&_SS_DISABLE != 0 {
+                       signalstack(&_g_.m.gsignal.stack)
+                       _g_.m.newSigstack = true
+               } else {
+                       // Use existing signal stack.
+                       stsp := uintptr(unsafe.Pointer(st.ss_sp))
+                       _g_.m.gsignal.stack.lo = stsp
+                       _g_.m.gsignal.stack.hi = stsp + st.ss_size
+                       _g_.m.gsignal.stackguard0 = stsp + _StackGuard
+                       _g_.m.gsignal.stackguard1 = stsp + _StackGuard
+                       _g_.m.gsignal.stackAlloc = st.ss_size
+                       _g_.m.newSigstack = false
+               }
        }
 
        // restore signal mask from m.sigmask and unblock essential signals

diff --git a/src/runtime/os1_dragonfly.go b/src/runtime/os1_dragonfly.go
index a739ef5a72410d91c370723e302aa444482e2ae9..bf3e1ccb839b23383a6b745a1ad563a4ce08b667 100644 (file)
--- a/src/runtime/os1_dragonfly.go
+++ b/src/runtime/os1_dragonfly.go
@@ -140,22 +140,17 @@ func minit() {
        // m.procid is a uint64, but lwp_start writes an int32. Fix it up.
        _g_.m.procid = uint64(*(*int32)(unsafe.Pointer(&_g_.m.procid)))
 
-       // Initialize signal handling
-       var st sigaltstackt
-       sigaltstack(nil, &st)
-       if st.ss_flags&_SS_DISABLE != 0 {
-               signalstack(&_g_.m.gsignal.stack)
-               _g_.m.newSigstack = true
-       } else {
-               // Use existing signal stack.
-               stsp := uintptr(unsafe.Pointer(st.ss_sp))
-               _g_.m.gsignal.stack.lo = stsp
-               _g_.m.gsignal.stack.hi = stsp + st.ss_size
-               _g_.m.gsignal.stackguard0 = stsp + _StackGuard
-               _g_.m.gsignal.stackguard1 = stsp + _StackGuard
-               _g_.m.gsignal.stackAlloc = st.ss_size
-               _g_.m.newSigstack = false
-       }
+       // Initialize signal handling.
+
+       // On DragonFly a thread created by pthread_create inherits
+       // the signal stack of the creating thread.  We always create
+       // a new signal stack here, to avoid having two Go threads
+       // using the same signal stack.  This breaks the case of a
+       // thread created in C that calls sigaltstack and then calls a
+       // Go function, because we will lose track of the C code's
+       // sigaltstack, but it's the best we can do.
+       signalstack(&_g_.m.gsignal.stack)
+       _g_.m.newSigstack = true
 
        // restore signal mask from m.sigmask and unblock essential signals
        nmask := _g_.m.sigmask

diff --git a/src/runtime/os1_netbsd.go b/src/runtime/os1_netbsd.go
index 42199020e51546150d499e5a387b1db6d52a6a72..eab8eb87024e6a47911043981e0c45c148260faa 100644 (file)
--- a/src/runtime/os1_netbsd.go
+++ b/src/runtime/os1_netbsd.go
@@ -104,7 +104,7 @@ func newosproc(mp *m, stk unsafe.Pointer) {
        uc.uc_link = nil
        uc.uc_sigmask = sigset_all
 
-       lwp_mcontext_init(&uc.uc_mcontext, stk, mp, mp.g0, funcPC(mstart))
+       lwp_mcontext_init(&uc.uc_mcontext, stk, mp, mp.g0, funcPC(netbsdMstart))
 
        ret := lwp_create(unsafe.Pointer(&uc), 0, unsafe.Pointer(&mp.procid))
        if ret < 0 {
@@ -113,6 +113,19 @@ func newosproc(mp *m, stk unsafe.Pointer) {
        }
 }
 
+// netbsdMStart is the function call that starts executing a newly
+// created thread.  On NetBSD, a new thread inherits the signal stack
+// of the creating thread.  That confuses minit, so we remove that
+// signal stack here before calling the regular mstart.  It's a bit
+// baroque to remove a signal stack here only to add one in minit, but
+// it's a simple change that keeps NetBSD working like other OS's.
+// At this point all signals are blocked, so there is no race.
+//go:nosplit
+func netbsdMstart() {
+       signalstack(nil)
+       mstart()
+}
+
 func osinit() {
        ncpu = getncpu()
 }
@@ -159,22 +172,17 @@ func minit() {
        _g_ := getg()
        _g_.m.procid = uint64(lwp_self())
 
-       // Initialize signal handling
-       var st sigaltstackt
-       sigaltstack(nil, &st)
-       if st.ss_flags&_SS_DISABLE != 0 {
-               signalstack(&_g_.m.gsignal.stack)
-               _g_.m.newSigstack = true
-       } else {
-               // Use existing signal stack.
-               stsp := uintptr(unsafe.Pointer(st.ss_sp))
-               _g_.m.gsignal.stack.lo = stsp
-               _g_.m.gsignal.stack.hi = stsp + st.ss_size
-               _g_.m.gsignal.stackguard0 = stsp + _StackGuard
-               _g_.m.gsignal.stackguard1 = stsp + _StackGuard
-               _g_.m.gsignal.stackAlloc = st.ss_size
-               _g_.m.newSigstack = false
-       }
+       // Initialize signal handling.
+
+       // On NetBSD a thread created by pthread_create inherits the
+       // signal stack of the creating thread.  We always create a
+       // new signal stack here, to avoid having two Go threads using
+       // the same signal stack.  This breaks the case of a thread
+       // created in C that calls sigaltstack and then calls a Go
+       // function, because we will lose track of the C code's
+       // sigaltstack, but it's the best we can do.
+       signalstack(&_g_.m.gsignal.stack)
+       _g_.m.newSigstack = true
 
        // restore signal mask from m.sigmask and unblock essential signals
        nmask := _g_.m.sigmask

diff --git a/src/runtime/pprof/pprof.go b/src/runtime/pprof/pprof.go
index d32b31578d0f311023e8953ec6567bb628507596..7d677cb64e6c23e856d8d1f0bd9346e4ad3eeb4c 100644 (file)
--- a/src/runtime/pprof/pprof.go
+++ b/src/runtime/pprof/pprof.go
@@ -567,6 +567,14 @@ var cpu struct {
 // StartCPUProfile enables CPU profiling for the current process.
 // While profiling, the profile will be buffered and written to w.
 // StartCPUProfile returns an error if profiling is already enabled.
+//
+// On Unix-like systems, StartCPUProfile does not work by default for
+// Go code built with -buildmode=c-archive or -buildmode=c-shared.
+// StartCPUProfile relies on the SIGPROF signal, but that signal will
+// be delivered to the main program's SIGPROF signal handler (if any)
+// not to the one used by Go.  To make it work, call os/signal.Notify
+// for syscall.SIGPROF, but note that doing so may break any profiling
+// being done by the main program.
 func StartCPUProfile(w io.Writer) error {
        // The runtime routines allow a variable profiling rate,
        // but in practice operating systems cannot trigger signals

diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go
index 24bf9457e3682d38fbe7906532c317b8bc9b1c41..f7c1a46805adc06909b07829816a18268c6e5512 100644 (file)
--- a/src/runtime/pprof/pprof_test.go
+++ b/src/runtime/pprof/pprof_test.go
@@ -23,14 +23,14 @@ import (
        "unsafe"
 )
 
-func cpuHogger(f func()) {
+func cpuHogger(f func(), dur time.Duration) {
        // We only need to get one 100 Hz clock tick, so we've got
-       // a 25x safety buffer.
+       // a large safety buffer.
        // But do at least 500 iterations (which should take about 100ms),
        // otherwise TestCPUProfileMultithreaded can fail if only one
-       // thread is scheduled during the 250ms period.
+       // thread is scheduled during the testing period.
        t0 := time.Now()
-       for i := 0; i < 500 || time.Since(t0) < 250*time.Millisecond; i++ {
+       for i := 0; i < 500 || time.Since(t0) < dur; i++ {
                f()
        }
 }
@@ -68,20 +68,20 @@ func cpuHog2() {
 }
 
 func TestCPUProfile(t *testing.T) {
-       testCPUProfile(t, []string{"runtime/pprof_test.cpuHog1"}, func() {
-               cpuHogger(cpuHog1)
+       testCPUProfile(t, []string{"runtime/pprof_test.cpuHog1"}, func(dur time.Duration) {
+               cpuHogger(cpuHog1, dur)
        })
 }
 
 func TestCPUProfileMultithreaded(t *testing.T) {
        defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(2))
-       testCPUProfile(t, []string{"runtime/pprof_test.cpuHog1", "runtime/pprof_test.cpuHog2"}, func() {
+       testCPUProfile(t, []string{"runtime/pprof_test.cpuHog1", "runtime/pprof_test.cpuHog2"}, func(dur time.Duration) {
                c := make(chan int)
                go func() {
-                       cpuHogger(cpuHog1)
+                       cpuHogger(cpuHog1, dur)
                        c <- 1
                }()
-               cpuHogger(cpuHog2)
+               cpuHogger(cpuHog2, dur)
                <-c
        })
 }
@@ -92,11 +92,11 @@ func parseProfile(t *testing.T, bytes []byte, f func(uintptr, []uintptr)) {
        val := *(*[]uintptr)(unsafe.Pointer(&bytes))
        val = val[:l]
 
-       // 5 for the header, 2 for the per-sample header on at least one sample, 3 for the trailer.
-       if l < 5+2+3 {
+       // 5 for the header, 3 for the trailer.
+       if l < 5+3 {
                t.Logf("profile too short: %#x", val)
                if badOS[runtime.GOOS] {
-                       t.Skipf("ignoring failure on %s; see golang.org/issue/6047", runtime.GOOS)
+                       t.Skipf("ignoring failure on %s; see golang.org/issue/13841", runtime.GOOS)
                        return
                }
                t.FailNow()
@@ -120,7 +120,7 @@ func parseProfile(t *testing.T, bytes []byte, f func(uintptr, []uintptr)) {
        }
 }
 
-func testCPUProfile(t *testing.T, need []string, f func()) {
+func testCPUProfile(t *testing.T, need []string, f func(dur time.Duration)) {
        switch runtime.GOOS {
        case "darwin":
                switch runtime.GOARCH {
@@ -138,12 +138,55 @@ func testCPUProfile(t *testing.T, need []string, f func()) {
                t.Skip("skipping on plan9")
        }
 
-       var prof bytes.Buffer
-       if err := StartCPUProfile(&prof); err != nil {
-               t.Fatal(err)
+       const maxDuration = 5 * time.Second
+       // If we're running a long test, start with a long duration
+       // because some of the tests (e.g., TestStackBarrierProfiling)
+       // are trying to make sure something *doesn't* happen.
+       duration := 5 * time.Second
+       if testing.Short() {
+               duration = 200 * time.Millisecond
+       }
+
+       // Profiling tests are inherently flaky, especially on a
+       // loaded system, such as when this test is running with
+       // several others under go test std. If a test fails in a way
+       // that could mean it just didn't run long enough, try with a
+       // longer duration.
+       for duration <= maxDuration {
+               var prof bytes.Buffer
+               if err := StartCPUProfile(&prof); err != nil {
+                       t.Fatal(err)
+               }
+               f(duration)
+               StopCPUProfile()
+
+               if profileOk(t, need, prof, duration) {
+                       return
+               }
+
+               duration *= 2
+               if duration <= maxDuration {
+                       t.Logf("retrying with %s duration", duration)
+               }
        }
-       f()
-       StopCPUProfile()
+
+       if badOS[runtime.GOOS] {
+               t.Skipf("ignoring failure on %s; see golang.org/issue/13841", runtime.GOOS)
+               return
+       }
+       // Ignore the failure if the tests are running in a QEMU-based emulator,
+       // QEMU is not perfect at emulating everything.
+       // IN_QEMU environmental variable is set by some of the Go builders.
+       // IN_QEMU=1 indicates that the tests are running in QEMU. See issue 9605.
+       if os.Getenv("IN_QEMU") == "1" {
+               t.Skip("ignore the failure in QEMU; see golang.org/issue/9605")
+               return
+       }
+       t.FailNow()
+}
+
+func profileOk(t *testing.T, need []string, prof bytes.Buffer, duration time.Duration) (ok bool) {
+       ok = true
 
        // Check that profile is well formed and contains need.
        have := make([]uintptr, len(need))
@@ -172,11 +215,18 @@ func testCPUProfile(t *testing.T, need []string, f func()) {
                // On some windows machines we end up with
                // not enough samples due to coarse timer
                // resolution. Let it go.
-               t.Skip("too few samples on Windows (golang.org/issue/10842)")
+               t.Log("too few samples on Windows (golang.org/issue/10842)")
+               return false
+       }
+
+       // Check that we got a reasonable number of samples.
+       if ideal := uintptr(duration * 100 / time.Second); samples == 0 || samples < ideal/4 {
+               t.Logf("too few samples; got %d, want at least %d, ideally %d", samples, ideal/4, ideal)
+               ok = false
        }
 
        if len(need) == 0 {
-               return
+               return ok
        }
 
        var total uintptr
@@ -184,9 +234,8 @@ func testCPUProfile(t *testing.T, need []string, f func()) {
                total += have[i]
                t.Logf("%s: %d\n", name, have[i])
        }
-       ok := true
        if total == 0 {
-               t.Logf("no CPU profile samples collected")
+               t.Logf("no samples in expected functions")
                ok = false
        }
        // We'd like to check a reasonable minimum, like
@@ -200,22 +249,7 @@ func testCPUProfile(t *testing.T, need []string, f func()) {
                        ok = false
                }
        }
-
-       if !ok {
-               if badOS[runtime.GOOS] {
-                       t.Skipf("ignoring failure on %s; see golang.org/issue/6047", runtime.GOOS)
-                       return
-               }
-               // Ignore the failure if the tests are running in a QEMU-based emulator,
-               // QEMU is not perfect at emulating everything.
-               // IN_QEMU environmental variable is set by some of the Go builders.
-               // IN_QEMU=1 indicates that the tests are running in QEMU. See issue 9605.
-               if os.Getenv("IN_QEMU") == "1" {
-                       t.Skip("ignore the failure in QEMU; see golang.org/issue/9605")
-                       return
-               }
-               t.FailNow()
-       }
+       return ok
 }
 
 // Fork can hang if preempted with signals frequently enough (see issue 5517).
@@ -310,11 +344,7 @@ func TestGoroutineSwitch(t *testing.T) {
 
 // Test that profiling of division operations is okay, especially on ARM. See issue 6681.
 func TestMathBigDivide(t *testing.T) {
-       testCPUProfile(t, nil, func() {
-               duration := 5 * time.Second
-               if testing.Short() {
-                       duration = 200 * time.Millisecond
-               }
+       testCPUProfile(t, nil, func(duration time.Duration) {
                t := time.After(duration)
                pi := new(big.Int)
                for {
@@ -370,13 +400,9 @@ func TestStackBarrierProfiling(t *testing.T) {
                return
        }
 
-       testCPUProfile(t, nil, func() {
-               // This is long enough that we're likely to get one or
-               // two samples in stackBarrier.
-               duration := 5 * time.Second
-               if testing.Short() {
-                       duration = 200 * time.Millisecond
-               }
+       testCPUProfile(t, nil, func(duration time.Duration) {
+               // In long mode, we're likely to get one or two
+               // samples in stackBarrier.
                t := time.After(duration)
                for {
                        deepStack(1000)
@@ -399,11 +425,13 @@ func deepStack(depth int) int {
        return deepStack(depth-1) + 1
 }
 
-// Operating systems that are expected to fail the tests. See issue 6047.
+// Operating systems that are expected to fail the tests. See issue 13841.
 var badOS = map[string]bool{
-       "darwin": true,
-       "netbsd": true,
-       "plan9":  true,
+       "darwin":    true,
+       "netbsd":    true,
+       "plan9":     true,
+       "dragonfly": true,
+       "solaris":   true,
 }
 
 func TestBlockProfile(t *testing.T) {

diff --git a/src/runtime/proc.go b/src/runtime/proc.go
index a7e94a9c1d421f403b776ecce04547c489034c61..d1f5088b5029bef85c0380c0dd068e13bbb8df2e 100644 (file)
--- a/src/runtime/proc.go
+++ b/src/runtime/proc.go
@@ -1602,11 +1602,19 @@ func startm(_p_ *p, spinning bool) {
 // Always runs without a P, so write barriers are not allowed.
 //go:nowritebarrier
 func handoffp(_p_ *p) {
+       // handoffp must start an M in any situation where
+       // findrunnable would return a G to run on _p_.
+
        // if it has local work, start it straight away
        if !runqempty(_p_) || sched.runqsize != 0 {
                startm(_p_, false)
                return
        }
+       // if it has GC work, start it straight away
+       if gcBlackenEnabled != 0 && gcMarkWorkAvailable(_p_) {
+               startm(_p_, false)
+               return
+       }
        // no local work, check that there are no spinning/idle M's,
        // otherwise our help is not required
        if atomic.Load(&sched.nmspinning)+atomic.Load(&sched.npidle) == 0 && atomic.Cas(&sched.nmspinning, 0, 1) { // TODO: fast atomic
@@ -1787,6 +1795,10 @@ func execute(gp *g, inheritTime bool) {
 func findrunnable() (gp *g, inheritTime bool) {
        _g_ := getg()
 
+       // The conditions here and in handoffp must agree: if
+       // findrunnable would return a G to run, handoffp must start
+       // an M.
+
 top:
        if sched.gcwaiting != 0 {
                gcstopm()
@@ -1867,9 +1879,9 @@ stop:
        // We have nothing to do. If we're in the GC mark phase, can
        // safely scan and blacken objects, and have work to do, run
        // idle-time marking rather than give up the P.
-       if _p_ := _g_.m.p.ptr(); gcBlackenEnabled != 0 && _p_.gcBgMarkWorker != nil && gcMarkWorkAvailable(_p_) {
+       if _p_ := _g_.m.p.ptr(); gcBlackenEnabled != 0 && _p_.gcBgMarkWorker != 0 && gcMarkWorkAvailable(_p_) {
                _p_.gcMarkWorkerMode = gcMarkWorkerIdleMode
-               gp := _p_.gcBgMarkWorker
+               gp := _p_.gcBgMarkWorker.ptr()
                casgstatus(gp, _Gwaiting, _Grunnable)
                if trace.enabled {
                        traceGoUnpark(gp, 0)
@@ -3206,13 +3218,15 @@ func procresize(nprocs int32) *p {
                }
                // if there's a background worker, make it runnable and put
                // it on the global queue so it can clean itself up
-               if p.gcBgMarkWorker != nil {
-                       casgstatus(p.gcBgMarkWorker, _Gwaiting, _Grunnable)
+               if gp := p.gcBgMarkWorker.ptr(); gp != nil {
+                       casgstatus(gp, _Gwaiting, _Grunnable)
                        if trace.enabled {
-                               traceGoUnpark(p.gcBgMarkWorker, 0)
+                               traceGoUnpark(gp, 0)
                        }
-                       globrunqput(p.gcBgMarkWorker)
-                       p.gcBgMarkWorker = nil
+                       globrunqput(gp)
+                       // This assignment doesn't race because the
+                       // world is stopped.
+                       p.gcBgMarkWorker.set(nil)
                }
                for i := range p.sudogbuf {
                        p.sudogbuf[i] = nil

diff --git a/src/runtime/proc_test.go b/src/runtime/proc_test.go
index f3e90bcbd76b4ea7dc33dc38cbd466e92581cbb2..9e5960bd2af612232e58e172d7071d3a1ae7cb98 100644 (file)
--- a/src/runtime/proc_test.go
+++ b/src/runtime/proc_test.go
@@ -345,12 +345,27 @@ func TestNumGoroutine(t *testing.T) {
        }
 
        buf := make([]byte, 1<<20)
-       buf = buf[:runtime.Stack(buf, true)]
 
-       n := runtime.NumGoroutine()
+       // Try up to 10 times for a match before giving up.
+       // This is a fundamentally racy check but it's important
+       // to notice if NumGoroutine and Stack are _always_ out of sync.
+       for i := 0; ; i++ {
+               // Give goroutines about to exit a chance to exit.
+               // The NumGoroutine and Stack below need to see
+               // the same state of the world, so anything we can do
+               // to keep it quiet is good.
+               runtime.Gosched()
+
+               n := runtime.NumGoroutine()
+               buf = buf[:runtime.Stack(buf, true)]
 
-       if nstk := strings.Count(string(buf), "goroutine "); n != nstk {
-               t.Fatalf("NumGoroutine=%d, but found %d goroutines in stack dump", n, nstk)
+               nstk := strings.Count(string(buf), "goroutine ")
+               if n == nstk {
+                       break
+               }
+               if i >= 10 {
+                       t.Fatalf("NumGoroutine=%d, but found %d goroutines in stack dump: %s", n, nstk, buf)
+               }
        }
 }
 

diff --git a/src/runtime/race/output_test.go b/src/runtime/race/output_test.go
index a9f9f0fbd5deb485c35338545b79c1a4cabe65e3..0c71a019dd59dd9f70102d423e39a95100a6bd9b 100644 (file)
--- a/src/runtime/race/output_test.go
+++ b/src/runtime/race/output_test.go
@@ -51,7 +51,10 @@ func TestOutput(t *testing.T) {
                        }
                        cmd.Env = append(cmd.Env, env)
                }
-               cmd.Env = append(cmd.Env, "GORACE="+test.gorace)
+               cmd.Env = append(cmd.Env,
+                       "GOMAXPROCS=1", // see comment in race_test.go
+                       "GORACE="+test.gorace,
+               )
                got, _ := cmd.CombinedOutput()
                if !regexp.MustCompile(test.re).MatchString(string(got)) {
                        t.Fatalf("failed test case %v, expect:\n%v\ngot:\n%s",

diff --git a/src/runtime/race/race_test.go b/src/runtime/race/race_test.go
index 6898e749007c2dfebe766f8902191fc61e0823e7..748f33883bd5be5d0b6bf8bfe37a182145026104 100644 (file)
--- a/src/runtime/race/race_test.go
+++ b/src/runtime/race/race_test.go
@@ -155,7 +155,20 @@ func runTests() ([]byte, error) {
                }
                cmd.Env = append(cmd.Env, env)
        }
-       cmd.Env = append(cmd.Env, `GORACE=suppress_equal_stacks=0 suppress_equal_addresses=0 exitcode=0`)
+       // We set GOMAXPROCS=1 to prevent test flakiness.
+       // There are two sources of flakiness:
+       // 1. Some tests rely on particular execution order.
+       //    If the order is different, race does not happen at all.
+       // 2. Ironically, ThreadSanitizer runtime contains a logical race condition
+       //    that can lead to false negatives if racy accesses happen literally at the same time.
+       // Tests used to work reliably in the good old days of GOMAXPROCS=1.
+       // So let's set it for now. A more reliable solution is to explicitly annotate tests
+       // with required execution order by means of a special "invisible" synchronization primitive
+       // (that's what is done for C++ ThreadSanitizer tests). This is issue #14119.
+       cmd.Env = append(cmd.Env,
+               "GOMAXPROCS=1",
+               "GORACE=suppress_equal_stacks=0 suppress_equal_addresses=0 exitcode=0",
+       )
        return cmd.CombinedOutput()
 }
 

diff --git a/src/runtime/race/testdata/issue12225_test.go b/src/runtime/race/testdata/issue12225_test.go
index 3b0b8ec289348392a81be35ccf48d875df27d3dd..0494493b2e9f68d1020e99a838f17688b7c94921 100644 (file)
--- a/src/runtime/race/testdata/issue12225_test.go
+++ b/src/runtime/race/testdata/issue12225_test.go
@@ -4,9 +4,16 @@
 
 package race_test
 
+import "unsafe"
+
 // golang.org/issue/12225
 // The test is that this compiles at all.
 
+//go:noinline
+func convert(s string) []byte {
+       return []byte(s)
+}
+
 func issue12225() {
        println(*(*int)(unsafe.Pointer(&convert("")[0])))
        println(*(*int)(unsafe.Pointer(&[]byte("")[0])))

diff --git a/src/runtime/runtime2.go b/src/runtime/runtime2.go
index 54c4686f7991fd185016fe28a5a04d12e8090a4e..917fe89d38856b26c4d0e07f916f0d95965f3d7c 100644 (file)
--- a/src/runtime/runtime2.go
+++ b/src/runtime/runtime2.go
@@ -388,7 +388,7 @@ type p struct {
 
        // Per-P GC state
        gcAssistTime     int64 // Nanoseconds in assistAlloc
-       gcBgMarkWorker   *g
+       gcBgMarkWorker   guintptr
        gcMarkWorkerMode gcMarkWorkerMode
 
        // gcw is this P's GC work buffer cache. The work buffer is

diff --git a/src/runtime/runtime_test.go b/src/runtime/runtime_test.go
index 664c1180c427a831740e6efab266e05e662a3ee8..a6150a77ee9502b99b9673af7d7d86272d75024e 100644 (file)
--- a/src/runtime/runtime_test.go
+++ b/src/runtime/runtime_test.go
@@ -308,3 +308,24 @@ func TestAppendSliceGrowth(t *testing.T) {
                }
        }
 }
+
+func TestGoroutineProfileTrivial(t *testing.T) {
+       // Calling GoroutineProfile twice in a row should find the same number of goroutines,
+       // but it's possible there are goroutines just about to exit, so we might end up
+       // with fewer in the second call. Try a few times; it should converge once those
+       // zombies are gone.
+       for i := 0; ; i++ {
+               n1, ok := GoroutineProfile(nil) // should fail, there's at least 1 goroutine
+               if n1 < 1 || ok {
+                       t.Fatalf("GoroutineProfile(nil) = %d, %v, want >0, false", n1, ok)
+               }
+               n2, ok := GoroutineProfile(make([]StackRecord, n1))
+               if n2 == n1 && ok {
+                       break
+               }
+               t.Logf("GoroutineProfile(%d) = %d, %v, want %d, true", n1, n2, ok, n1)
+               if i >= 10 {
+                       t.Fatalf("GoroutineProfile not converging")
+               }
+       }
+}

diff --git a/src/runtime/stack_test.go b/src/runtime/stack_test.go
index fa073f19adb5f5e5a5f1fd1d80b82ba56ddedf37..928d1eca20a7fec865c412a4157d81a66edc79f9 100644 (file)
--- a/src/runtime/stack_test.go
+++ b/src/runtime/stack_test.go
@@ -111,7 +111,8 @@ func TestStackGrowth(t *testing.T) {
                select {
                case <-done:
                case <-time.After(20 * time.Second):
-                       t.Fatal("finalizer did not run")
+                       t.Error("finalizer did not run")
+                       return
                }
        }()
        wg.Wait()
@@ -191,7 +192,6 @@ func TestStackGrowthCallback(t *testing.T) {
                        <-done
                })
        }()
-
        wg.Wait()
 }
 

diff --git a/src/runtime/string.go b/src/runtime/string.go
index f8ccd41b1d3d2cbc1121ab11eeed8a748abd7014..dd04bda04ba3cb37833d1201c3defc70ec035310 100644 (file)
--- a/src/runtime/string.go
+++ b/src/runtime/string.go
@@ -139,7 +139,7 @@ func slicebytetostringtmp(b []byte) string {
 func stringtoslicebyte(buf *tmpBuf, s string) []byte {
        var b []byte
        if buf != nil && len(s) <= len(buf) {
-               b = buf[:len(s)]
+               b = buf[:len(s):len(s)]
        } else {
                b = rawbyteslice(len(s))
        }
@@ -171,7 +171,7 @@ func stringtoslicerune(buf *[tmpStringBufSize]rune, s string) []rune {
        }
        var a []rune
        if buf != nil && n <= len(buf) {
-               a = buf[:n]
+               a = buf[:n:n]
        } else {
                a = rawruneslice(n)
        }

diff --git a/src/runtime/string_test.go b/src/runtime/string_test.go
index 318a5532e521c07fffe17c292ec00cdef5b9b9ac..150a25520adbc3e427ca8cb7dc68e59e1a59feb4 100644 (file)
--- a/src/runtime/string_test.go
+++ b/src/runtime/string_test.go
@@ -222,3 +222,18 @@ func TestRangeStringCast(t *testing.T) {
                t.Fatalf("want 0 allocs, got %v", n)
        }
 }
+
+func TestString2Slice(t *testing.T) {
+       // Make sure we don't return slices that expose
+       // an unzeroed section of stack-allocated temp buf
+       // between len and cap.  See issue 14232.
+       s := "foož"
+       b := ([]byte)(s)
+       if cap(b) != 5 {
+               t.Errorf("want cap of 5, got %d", cap(b))
+       }
+       r := ([]rune)(s)
+       if cap(r) != 4 {
+               t.Errorf("want cap of 4, got %d", cap(r))
+       }
+}

diff --git a/src/runtime/sys_darwin_386.s b/src/runtime/sys_darwin_386.s
index c516ef2da81a8195be1d10d37a0f1d93c9465ab0..ad3dca444a830cf0028b07473e1cb7b80bf8eeb1 100644 (file)
--- a/src/runtime/sys_darwin_386.s
+++ b/src/runtime/sys_darwin_386.s
@@ -242,15 +242,21 @@ TEXT runtime·sigaction(SB),NOSPLIT,$0
        MOVL    $0xf1, 0xf1  // crash
        RET
 
-TEXT runtime·sigfwd(SB),NOSPLIT,$12-16
-       MOVL    sig+4(FP), AX
-       MOVL    AX, 0(SP)
-       MOVL    info+8(FP), AX
-       MOVL    AX, 4(SP)
-       MOVL    ctx+12(FP), AX
-       MOVL    AX, 8(SP)
+TEXT runtime·sigfwd(SB),NOSPLIT,$0-16
        MOVL    fn+0(FP), AX
+       MOVL    sig+4(FP), BX
+       MOVL    info+8(FP), CX
+       MOVL    ctx+12(FP), DX
+       MOVL    SP, SI
+       SUBL    $32, SP         // align stack; handler might be C code
+       ANDL    $~15, SP
+       MOVL    BX, 0(SP)
+       MOVL    CX, 4(SP)
+       MOVL    DX, 8(SP)
+       MOVL    SI, 12(SP)
        CALL    AX
+       MOVL    12(SP), AX
+       MOVL    AX, SP
        RET
 
 TEXT runtime·sigreturn(SB),NOSPLIT,$12-8

diff --git a/src/runtime/sys_dragonfly_amd64.s b/src/runtime/sys_dragonfly_amd64.s
index d1b94e1bfdc18edcead2bc25e5a9676da0a4ab1a..4e4d793c43b7387ddfe5b7d5b1cb1ee649a66bf1 100644 (file)
--- a/src/runtime/sys_dragonfly_amd64.s
+++ b/src/runtime/sys_dragonfly_amd64.s
@@ -51,6 +51,18 @@ TEXT runtime·lwp_start(SB),NOSPLIT,$0
        MOVQ    R13, g_m(DI)
        MOVQ    DI, g(CX)
 
+       // On DragonFly, a new thread inherits the signal stack of the
+       // creating thread.  That confuses minit, so we remove that
+       // signal stack here before calling the regular mstart.  It's
+       // a bit baroque to remove a signal stack here only to add one
+       // in minit, but it's a simple change that keeps DragonFly
+       // working like other OS's.  At this point all signals are
+       // blocked, so there is no race.
+       SUBQ    $8, SP
+       MOVQ    $0, 0(SP)
+       CALL    runtime·signalstack(SB)
+       ADDQ    $8, SP
+
        CALL    runtime·stackcheck(SB)
        CALL    runtime·mstart(SB)
 

diff --git a/src/runtime/sys_netbsd_amd64.s b/src/runtime/sys_netbsd_amd64.s
index 35a1b5dd00324a7d7a553f685f194a96487f7e28..fb21f1155ab4b01f56c70b08c93d45ff0496d9ac 100644 (file)
--- a/src/runtime/sys_netbsd_amd64.s
+++ b/src/runtime/sys_netbsd_amd64.s
@@ -245,11 +245,13 @@ TEXT runtime·sigfwd(SB),NOSPLIT,$0-32
        CALL    AX
        RET
 
-TEXT runtime·sigtramp(SB),NOSPLIT,$24
+TEXT runtime·sigtramp(SB),NOSPLIT,$32
        MOVQ    DI, 0(SP)   // signum
        MOVQ    SI, 8(SP)   // info
        MOVQ    DX, 16(SP)  // ctx
+       MOVQ    R15, 24(SP) // for sigreturn
        CALL    runtime·sigtrampgo(SB)
+       MOVQ    24(SP), R15
        RET
 
 TEXT runtime·mmap(SB),NOSPLIT,$0

diff --git a/src/runtime/time.go b/src/runtime/time.go
index ffe75905263165f898030a2b8a4a7e077577dded..3f8f6968c2ab2c17f46ce5aecf3122b5b20c714d 100644 (file)
--- a/src/runtime/time.go
+++ b/src/runtime/time.go
@@ -16,7 +16,7 @@ type timer struct {
        i int // heap index
 
        // Timer wakes up at when, and then at when+period, ... (period > 0 only)
-       // each time calling f(now, arg) in the timer goroutine, so f must be
+       // each time calling f(arg, now) in the timer goroutine, so f must be
        // a well-behaved function and not block.
        when   int64
        period int64

diff --git a/src/runtime/trace.go b/src/runtime/trace.go
index 58956383a3b18a25df5a191daac5eebd0d585cb7..805c34f483446ef07806524c619ec4e8cf6df68a 100644 (file)
--- a/src/runtime/trace.go
+++ b/src/runtime/trace.go
@@ -529,7 +529,12 @@ func traceEvent(ev byte, skip int, args ...uint64) {
                        nstk = callers(skip, buf.stk[:])
                } else if gp != nil {
                        gp = mp.curg
-                       nstk = gcallers(gp, skip, buf.stk[:])
+                       // This may happen when tracing a system call,
+                       // so we must lock the stack.
+                       if gcTryLockStackBarriers(gp) {
+                               nstk = gcallers(gp, skip, buf.stk[:])
+                               gcUnlockStackBarriers(gp)
+                       }
                }
                if nstk > 0 {
                        nstk-- // skip runtime.goexit

diff --git a/src/sync/waitgroup_test.go b/src/sync/waitgroup_test.go
index a5816609408d9b3a2aa654a9a356844c8ec31a6e..8ec34fd343bee1332934b676c9b33a598b9c6afa 100644 (file)
--- a/src/sync/waitgroup_test.go
+++ b/src/sync/waitgroup_test.go
@@ -128,13 +128,16 @@ func TestWaitGroupMisuse3(t *testing.T) {
                }
        }()
        defer runtime.GOMAXPROCS(runtime.GOMAXPROCS(4))
-       done := make(chan interface{}, 1)
+       done := make(chan interface{}, 2)
        // The detection is opportunistically, so we want it to panic
        // at least in one run out of a million.
        for i := 0; i < 1e6; i++ {
                var wg WaitGroup
                wg.Add(1)
                go func() {
+                       defer func() {
+                               done <- recover()
+                       }()
                        wg.Done()
                }()
                go func() {
@@ -150,8 +153,10 @@ func TestWaitGroupMisuse3(t *testing.T) {
                        wg.Wait()
                }()
                wg.Wait()
-               if err := <-done; err != nil {
-                       panic(err)
+               for j := 0; j < 2; j++ {
+                       if err := <-done; err != nil {
+                               panic(err)
+                       }
                }
        }
        t.Fatal("Should panic")

diff --git a/src/text/template/doc.go b/src/text/template/doc.go
index 6c60091bc54b51b122130839b0a2c09184f0faf3..df8c95f8c8949e7ec05b5e68f54d486598c06dec 100644 (file)
--- a/src/text/template/doc.go
+++ b/src/text/template/doc.go
@@ -64,7 +64,7 @@ space, horizontal tab, carriage return, and newline.
 Actions
 
 Here is the list of actions. "Arguments" and "pipelines" are evaluations of
-data, defined in detail below.
+data, defined in detail in the corresponding sections that follow.
 
 */
 //     {{/* a comment */}}
@@ -200,6 +200,8 @@ field of a struct, the function is not invoked automatically, but it
 can be used as a truth value for an if action and the like. To invoke
 it, use the call function, defined below.
 
+Pipelines
+
 A pipeline is a possibly chained sequence of "commands". A command is a simple
 value (argument) or a function or method call, possibly with multiple arguments:
 
@@ -217,8 +219,6 @@ value (argument) or a function or method call, possibly with multiple arguments:
                        function(Argument1, etc.)
                Functions and function names are described below.
 
-Pipelines
-
 A pipeline may be "chained" by separating a sequence of commands with pipeline
 characters '|'. In a chained pipeline, the result of the each command is
 passed as the last argument of the following command. The output of the final

diff --git a/src/time/zoneinfo.go b/src/time/zoneinfo.go
index c8e53a27cf02328ffc8a16909e95dcbea219765d..c56743933f92d0ff62e0d7d1b98c9b71c5f91c4e 100644 (file)
--- a/src/time/zoneinfo.go
+++ b/src/time/zoneinfo.go
@@ -21,7 +21,7 @@ type Location struct {
        // To avoid the binary search through tx, keep a
        // static one-element cache that gives the correct
        // zone for the time when the Location was created.
-       // if cacheStart <= t <= cacheEnd,
+       // if cacheStart <= t < cacheEnd,
        // lookup can return cacheZone.
        // The units for cacheStart and cacheEnd are seconds
        // since January 1, 1970 UTC, to match the argument

diff --git a/src/unsafe/unsafe.go b/src/unsafe/unsafe.go
index 752792f41bf5bc6dfcd05f10c3e8ac588ab939dc..532fa4aa2294560f95d6df0631dceb47ed612920 100644 (file)
--- a/src/unsafe/unsafe.go
+++ b/src/unsafe/unsafe.go
@@ -15,13 +15,160 @@ package unsafe
 type ArbitraryType int
 
 // Pointer represents a pointer to an arbitrary type.  There are four special operations
-// available for type Pointer that are not available for other types.
-//     1) A pointer value of any type can be converted to a Pointer.
-//     2) A Pointer can be converted to a pointer value of any type.
-//     3) A uintptr can be converted to a Pointer.
-//     4) A Pointer can be converted to a uintptr.
+// available for type Pointer that are not available for other types:
+//     - A pointer value of any type can be converted to a Pointer.
+//     - A Pointer can be converted to a pointer value of any type.
+//     - A uintptr can be converted to a Pointer.
+//     - A Pointer can be converted to a uintptr.
 // Pointer therefore allows a program to defeat the type system and read and write
 // arbitrary memory. It should be used with extreme care.
+//
+// The following patterns involving Pointer are valid.
+// Code not using these patterns is likely to be invalid today
+// or to become invalid in the future.
+// Even the valid patterns below come with important caveats.
+//
+// Running "go vet" can help find uses of Pointer that do not conform to these patterns,
+// but silence from "go vet" is not a guarantee that the code is valid.
+//
+// (1) Conversion of a *T1 to Pointer to *T2.
+//
+// Provided that T2 is no larger than T1 and that the two share an equivalent
+// memory layout, this conversion allows reinterpreting data of one type as
+// data of another type. An example is the implementation of
+// math.Float64bits:
+//
+//     func Float64bits(f float64) uint64 {
+//             return *(*uint64)(unsafe.Pointer(&f))
+//     }
+//
+// (2) Conversion of a Pointer to a uintptr (but not back to Pointer).
+//
+// Converting a Pointer to a uintptr produces the memory address of the value
+// pointed at, as an integer. The usual use for such a uintptr is to print it.
+//
+// Conversion of a uintptr back to Pointer is not valid in general.
+//
+// A uintptr is an integer, not a reference.
+// Converting a Pointer to a uintptr creates an integer value
+// with no pointer semantics.
+// Even if a uintptr holds the address of some object,
+// the garbage collector will not update that uintptr's value
+// if the object moves, nor will that uintptr keep the object
+// from being reclaimed.
+//
+// The remaining patterns enumerate the only valid conversions
+// from uintptr to Pointer.
+//
+// (3) Conversion of a Pointer to a uintptr and back, with arithmetic.
+//
+// If p points into an allocated object, it can be advanced through the object
+// by conversion to uintptr, addition of an offset, and conversion back to Pointer.
+//
+//     p = unsafe.Pointer(uintptr(p) + offset)
+//
+// The most common use of this pattern is to access fields in a struct
+// or elements of an array:
+//
+//     // equivalent to f := unsafe.Pointer(&s.f)
+//     f := unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + unsafe.Offsetof(s.f))
+//
+//     // equivalent to e := unsafe.Pointer(&x[i])
+//     e := unsafe.Pointer(uintptr(unsafe.Pointer(&x[0])) + i*unsafe.Sizeof(x[0]))
+//
+// It is valid both to add and to subtract offsets from a pointer in this way,
+// but the result must continue to point into the original allocated object.
+// Unlike in C, it is not valid to advance a pointer just beyond the end of
+// its original allocation:
+//
+//     // INVALID: end points outside allocated space.
+//     var s thing
+//     end = unsafe.Pointer(uintptr(unsafe.Pointer(&s)) + unsafe.Sizeof(s))
+//
+//     // INVALID: end points outside allocated space.
+//     b := make([]byte, n)
+//     end = unsafe.Pointer(uintptr(unsafe.Pointer(&b[0])) + uintptr(n))
+//
+// Note that both conversions must appear in the same expression, with only
+// the intervening arithmetic between them:
+//
+//     // INVALID: uintptr cannot be stored in variable
+//     // before conversion back to Pointer.
+//     u := uintptr(p)
+//     p = unsafe.Pointer(u + offset)
+//
+// (4) Conversion of a Pointer to a uintptr when calling syscall.Syscall.
+//
+// The Syscall functions in package syscall pass their uintptr arguments directly
+// to the operating system, which then may, depending on the details of the call,
+// reinterpret some of them as pointers.
+// That is, the system call implementation is implicitly converting certain arguments
+// back from uintptr to pointer.
+//
+// If a pointer argument must be converted to uintptr for use as an argument,
+// that conversion must appear in the call expression itself:
+//
+//     syscall.Syscall(SYS_READ, uintptr(fd), uintptr(unsafe.Pointer(p)), uintptr(n))
+//
+// The compiler handles a Pointer converted to a uintptr in the argument list of
+// a call to a function implemented in assembly by arranging that the referenced
+// allocated object, if any, is retained and not moved until the call completes,
+// even though from the types alone it would appear that the object is no longer
+// needed during the call.
+//
+// For the compiler to recognize this pattern,
+// the conversion must appear in the argument list:
+//
+//     // INVALID: uintptr cannot be stored in variable
+//     // before implicit conversion back to Pointer during system call.
+//     u := uintptr(unsafe.Pointer(p))
+//     syscall.Syscall(SYS_READ, uintptr(fd), u, uintptr(n))
+//
+// (5) Conversion of the result of reflect.Value.Pointer or reflect.Value.UnsafeAddr
+// from uintptr to Pointer.
+//
+// Package reflect's Value methods named Pointer and UnsafeAddr return type uintptr
+// instead of unsafe.Pointer to keep callers from changing the result to an arbitrary
+// type without first importing "unsafe". However, this means that the result is
+// fragile and must be converted to Pointer immediately after making the call,
+// in the same expression:
+//
+//     p := (*int)(unsafe.Pointer(reflect.ValueOf(new(int)).Pointer()))
+//
+// As in the cases above, it is invalid to store the result before the conversion:
+//
+//     // INVALID: uintptr cannot be stored in variable
+//     // before conversion back to Pointer.
+//     u := reflect.ValueOf(new(int)).Pointer()
+//     p := (*int)(unsafe.Pointer(u))
+//
+// (6) Conversion of a reflect.SliceHeader or reflect.StringHeader Data field to or from Pointer.
+//
+// As in the previous case, the reflect data structures SliceHeader and StringHeader
+// declare the field Data as a uintptr to keep callers from changing the result to
+// an arbitrary type without first importing "unsafe". However, this means that
+// SliceHeader and StringHeader are only valid when interpreting the content
+// of an actual slice or string value.
+//
+//     var s string
+//     hdr := (*reflect.StringHeader)(unsafe.Pointer(&s)) // case 1
+//     hdr.Data = uintptr(unsafe.Pointer(p))              // case 6 (this case)
+//     hdr.Len = uintptr(n)
+//
+// In this usage hdr.Data is really an alternate way to refer to the underlying
+// pointer in the slice header, not a uintptr variable itself.
+//
+// In general, reflect.SliceHeader and reflect.StringHeader should be used
+// only as *reflect.SliceHeader and *reflect.StringHeader pointing at actual
+// slices or strings, never as plain structs.
+// A program should not declare or allocate variables of these struct types.
+//
+//     // INVALID: a directly-declared header will not hold Data as a reference.
+//     var hdr reflect.StringHeader
+//     hdr.Data = uintptr(unsafe.Pointer(p))
+//     hdr.Len = uintptr(n)
+//     s := *(*string)(unsafe.Pointer(&hdr)) // p possibly already lost
+//
 type Pointer *ArbitraryType
 
 // Sizeof takes an expression x of any type and returns the size in bytes
@@ -36,7 +183,12 @@ func Sizeof(x ArbitraryType) uintptr
 // number of bytes between the start of the struct and the start of the field.
 func Offsetof(x ArbitraryType) uintptr
 
-// Alignof takes an expression x of any type and returns the alignment
+// Alignof takes an expression x of any type and returns the required alignment
 // of a hypothetical variable v as if v was declared via var v = x.
-// It is the largest value m such that the address of v is zero mod m.
+// It is the largest value m such that the address of v is always zero mod m.
+// It is the same as the value returned by reflect.TypeOf(x).Align().
+// As a special case, if a variable s is of struct type and f is a field
+// within that struct, then Alignof(s.f) will return the required alignment
+// of a field of that type within a struct.  This case is the same as the
+// value returned by reflect.TypeOf(s.f).FieldAlign().
 func Alignof(x ArbitraryType) uintptr

diff --git a/src/vendor/README b/src/vendor/README
new file mode 100644 (file)
index 0000000..e540318
--- /dev/null
+++ b/src/vendor/README
@@ -0,0 +1,8 @@
+This file needs to exist because the vendor directory needs
+to exist for some go/build tests to pass, and git can't track
+empty directories.
+
+In Go 1.7 we'll use this directory again. (In Go 1.6 we tried but
+reverted).
+
+See http://golang.org/issue/14047 for details.

diff --git a/test/fixedbugs/issue14006.go b/test/fixedbugs/issue14006.go
new file mode 100644 (file)
index 0000000..b56ed73
--- /dev/null
+++ b/test/fixedbugs/issue14006.go
@@ -0,0 +1,64 @@
+// errorcheck
+
+// Copyright 2016 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Literals that happen to resolve to named constants
+// may be used as label names (see issue 13684). Make
+// sure that other literals don't crash the compiler.
+
+package main
+
+const labelname = 1
+
+func main() {
+       goto labelname
+labelname:
+}
+
+func f() {
+       var x int
+       switch x {
+       case 1:
+               2:      // ERROR "unexpected :"
+       case 2:
+       }
+
+       switch x {
+       case 1:
+               2: ;    // ERROR "unexpected :"
+       case 2:
+       }
+
+       var y string
+       switch y {
+       case "foo":
+               "bar":  // ERROR "unexpected :"
+       case "bar":
+       }
+
+       switch y {
+       case "foo":
+               "bar": ;        // ERROR "unexpected :"
+       case "bar":
+       }
+
+       var z bool
+       switch {
+       case z:
+               labelname:      // ERROR "missing statement after label"
+       case false:
+       }
+
+       switch {
+       case z:
+               labelname:
+       }
+
+       switch {
+       case z:
+               labelname: ;
+       case false:
+       }
+}
\ No newline at end of file

diff --git a/test/fixedbugs/issue14010.go b/test/fixedbugs/issue14010.go
new file mode 100644 (file)
index 0000000..4fdbf76
--- /dev/null
+++ b/test/fixedbugs/issue14010.go
@@ -0,0 +1,15 @@
+// errorcheck
+
+// Copyright 2016 The Go Authors.  All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Verify that built-in types don't get printed with
+// (empty) package qualification.
+
+package main
+
+func main() {
+       true = false // ERROR "cannot assign to true"
+       byte = 0     // ERROR "not an expression" "cannot assign to byte"
+}

diff --git a/test/fixedbugs/issue14164.dir/a.go b/test/fixedbugs/issue14164.dir/a.go
new file mode 100644 (file)
index 0000000..bf03051
--- /dev/null
+++ b/test/fixedbugs/issue14164.dir/a.go
@@ -0,0 +1,47 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package a
+
+// F is an exported function, small enough to be inlined.
+// It defines a local interface with an unexported method
+// f, which will appear with a package-qualified method
+// name in the export data.
+func F(x interface{}) bool {
+       _, ok := x.(interface {
+               f()
+       })
+       return ok
+}
+
+// Like F but with the unexported interface method f
+// defined via an embedded interface t. The compiler
+// always flattens embedded interfaces so there should
+// be no difference between F and G. Alas, currently
+// G is not inlineable (at least via export data), so
+// the issue is moot, here.
+func G(x interface{}) bool {
+       type t0 interface {
+               f()
+       }
+       _, ok := x.(interface {
+               t0
+       })
+       return ok
+}
+
+// Like G but now the embedded interface is declared
+// at package level. This function is inlineable via
+// export data. The export data representation is like
+// for F.
+func H(x interface{}) bool {
+       _, ok := x.(interface {
+               t1
+       })
+       return ok
+}
+
+type t1 interface {
+       f()
+}

diff --git a/test/fixedbugs/issue14164.dir/main.go b/test/fixedbugs/issue14164.dir/main.go
new file mode 100644 (file)
index 0000000..bcc6a63
--- /dev/null
+++ b/test/fixedbugs/issue14164.dir/main.go
@@ -0,0 +1,12 @@
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+// Verify that we can import package "a" containing an inlineable
+// function F that declares a local interface with a non-exported
+// method f.
+import _ "./a"
+
+func main() {}

diff --git a/test/fixedbugs/issue14164.go b/test/fixedbugs/issue14164.go
new file mode 100644 (file)
index 0000000..5247599
--- /dev/null
+++ b/test/fixedbugs/issue14164.go
@@ -0,0 +1,7 @@
+// compiledir
+
+// Copyright 2016 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+ignored