diff --git a/doc/asm.html b/doc/asm.html index 2af2005143f..cce2fe2b8df 100644 --- a/doc/asm.html +++ b/doc/asm.html @@ -12,7 +12,7 @@ The document is not comprehensive.

The assembler is based on the input style of the Plan 9 assemblers, which is documented in detail -elsewhere. +elsewhere. 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 -this description) +this description) 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 3496db71d76..34e6e91938e 100644 --- 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 - The text editor sam): + The text editor sam):

diff --git a/doc/go1.6.html b/doc/go1.6.html index 61b2449dad0..6e3710cbad2 100644 --- a/doc/go1.6.html +++ b/doc/go1.6.html @@ -118,10 +118,10 @@ instead of generated from yacc.

-The compiler, linker, and go command have new flag -msan, +The compiler, linker, and go command have a new flag -msan, analogous to -race and only available on linux/amd64, that enables interoperation with the Clang MemorySanitizer. -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.

@@ -341,6 +341,19 @@ and changing the global timer resolution caused problems on some systems, so the call has been removed.

+

+When using -buildmode=c-archive or +-buildmode=c-shared 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 os/signal package for more +details. +

+

Reflect

@@ -451,20 +464,8 @@ Second, the new {{"{{"}}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 -

- -
-<title>{{"{{"}}block "title"}}Page Title{{"{{"}}end}}</title>
-<body>
-<h1>{{"{{"}}template "title"}}</h1>
-{{"{{"}}block "page"}}Main text{{"{{"}}end}}
-
- -

-defines the basic formatting of a web page. A program can then -overlay that template with new definitions for the "title" -and "page" blocks to reuse the formatting for another page. +There is an example +in the text/template package that demonstrates this new feature.

Minor changes to the library

@@ -588,7 +589,7 @@ Also in the encoding/asn1 package The encoding/base64 package's Decoder 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 Decoder therefore now handles inputs in unpadded encodings (like RawURLEncoding) 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 * was required to have type < Also in the fmt package, Scanf can now scan hexadecimal strings using %X, as an alias for %x. Both formats accept any mix of upper- and lower-case hexadecimal. -TODO: Keep? +TODO: Keep?
  • The image and -The image/color packages +image/color packages add NYCbCrA and -NYCbCrA +NYCbCrA types, to support Y'CbCr images with non-premultiplied alpha.
    • @@ -725,22 +726,31 @@ This is arguably a mistake but is not yet fixed. See https://golang.org/issue/13 The net/http package has a number of minor additions beyond the HTTP/2 support already discussed. First, the -FileServer now sorts its generated directory listings by file name. +FileServer now sorts its generated directory listings by file name. Second, the -Client now allows user code to set the +ServeFile function now refuses to serve a result +if the request's URL path contains “..” (dot-dot) as a path element. +Programs should typically use FileServer and +Dir +instead of calling ServeFile directly. +Programs that need to serve file content in response to requests for URLs containing dot-dot can +still call ServeContent. +Third, the +Client now allows user code to set the Expect: 100-continue header (see -Transport.ExpectContinueTimeout). -Third, there are -four new error codes from RFC 6585: +Transport.ExpectContinueTimeout). +Fourth, there are +five new error codes: StatusPreconditionRequired (428), StatusTooManyRequests (429), -StatusRequestHeaderFieldsTooLarge (431), -and -StatusNetworkAuthenticationRequired (511). -Fourth, the implementation and documentation of -CloseNotifier +StatusRequestHeaderFieldsTooLarge (431), and +StatusNetworkAuthenticationRequired (511) from RFC 6585, +as well as the recently-approved +StatusUnavailableForLegalReasons (451). +Fifth, the implementation and documentation of +CloseNotifier has been substantially changed. -The Hijacker +The Hijacker interface now works correctly on connections that have previously been used with CloseNotifier. The documentation now describes when CloseNotifier @@ -750,17 +760,17 @@ is expected to work.
  • Also in the net/http package, there are a few changes related to the handling of a -Request data structure with its Method field set to the empty string. +Request data structure with its Method field set to the empty string. An empty Method field has always been documented as an alias for "GET" and it remains so. However, Go 1.6 fixes a few routines that did not treat an empty Method the same as an explicit "GET". Most notably, in previous releases -Client followed redirects only with +Client followed redirects only with Method set explicitly to "GET"; in Go 1.6 Client also follows redirects for the empty Method. Finally, -NewRequest accepts a method argument that has not been +NewRequest accepts a method argument that has not been documented as allowed to be empty. In past releases, passing an empty method argument resulted in a Request with an empty Method field. @@ -825,7 +835,7 @@ In the os/exec package, Output method continues to return an ExitError when a command exits with an unsuccessful status. If standard error would otherwise have been discarded, -the returned ExitError now holds a prefix +the returned ExitError 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 ExitError's @@ -865,16 +875,18 @@ should only be used when contention has been observed.
  • The strconv package adds IsGraphic, +similar to IsPrint. +It also adds QuoteToGraphic, QuoteRuneToGraphic, AppendQuoteToGraphic, and AppendQuoteRuneToGraphic, analogous to -IsPrint, -QuoteToPrint, +QuoteToASCII, +QuoteRuneToASCII, and so on. -The Print family escapes all space characters except ASCII space (U+0020). +The ASCII family escapes all space characters except ASCII space (U+0020). In contrast, the Graphic family does not escape any Unicode space characters (category Zs).
    • diff --git a/doc/go_faq.html b/doc/go_faq.html index bcd12075b64..b5f97727876 100644 --- a/doc/go_faq.html +++ b/doc/go_faq.html @@ -98,7 +98,7 @@ What's the origin of the mascot?

    The mascot and logo were designed by Renée French, who also designed -Glenda, +Glenda, the Plan 9 bunny. The gopher is derived from one she used for an WFMU diff --git a/doc/install-source.html b/doc/install-source.html index 60931ada5da..332c72097ea 100644 --- a/doc/install-source.html +++ b/doc/install-source.html @@ -173,6 +173,21 @@ follow the instructions on the Git downloads page.

    +

    (Optional) Install a C compiler

    + +

    +To build a Go installation +with cgo support, which permits Go +programs to import C libraries, a C compiler such as gcc +or clang must be installed first. Do this using whatever +installation method is standard on the system. +

    + +

    +To build without cgo, set the environment variable +CGO_ENABLED=0 before running all.bash or +make.bash. +

    Fetch the repository

    @@ -184,7 +199,7 @@ Then clone the repository and check out the latest release tag:

     $ git clone https://go.googlesource.com/go
 $ cd go
-$ git checkout go1.5.2
+$ git checkout go1.5.3
    @@ -363,7 +378,7 @@ New releases are announced on the golang-announce mailing list. Each announcement mentions the latest release tag, for instance, -go1.5.2. +go1.5.3.

    diff --git a/lib/time/update.bash b/lib/time/update.bash index 3ef1df582cf..86b1f211000 100755 --- 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 73c30b45970..0207d6bcbc6 100644 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 0dd291f5ed1..834cde91991 100644 --- 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 + 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 + 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 787653c4825..b641ff60374 100644 --- 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 f4b4a3079fe..f4e7c458ec6 100755 --- 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 </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 592a91715e7..86fb530167d 100644 --- 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 index 00000000000..6a4453f7758 --- /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 index 00000000000..5360188c562 --- /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 index 00000000000..f6112933e56 --- /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 8dd79cc79c8..1eed3040cb0 100644 --- 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 9a0e20db1e1..10e81728757 100644 --- 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 8f7e8bf555d..72cf5d9cf42 100644 --- 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 4211ec7af7b..8fccbf7ca09 100644 --- 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) +// 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) -// 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 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 b6a51a837c0..c14a13cdb13 100644 --- 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 8df994e8d19..502a906a4ed 100644 --- 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 9da3664db12..9827d70ae19 100644 --- 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 6e339ad0b57..4bc7e2fb749 100644 --- 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) + t.Error(err) + return } - if result != string(expect) { - if false { // Enable to capture output. - fmt.Printf("%s", result) - os.Exit(1) + 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 } - 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]) + 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 } -func TestARMEndToEnd(t *testing.T) { - testEndToEnd(t, "arm") -} +// 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]+)(?:$|\))`) -func TestARM64EndToEnd(t *testing.T) { - testEndToEnd(t, "arm64") -} +// Same as in test/run.go +var ( + errRE = regexp.MustCompile(`// ERROR ?(.*)`) + errQuotesRE = regexp.MustCompile(`"([^"]*)"`) +) -func TestAMD64EndToEnd(t *testing.T) { - testEndToEnd(t, "amd64") +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) { - testEndToEnd(t, "386") + 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) { + 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", "arm64") +} + +func TestAMD64EndToEnd(t *testing.T) { + testEndToEnd(t, "amd64", "amd64") +} + +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 ecf52c5620e..bc6a495c987 100644 --- 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 9a42838be90..4258c5ce263 100644 --- 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 index be43ccbfbb6..00000000000 --- 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 6bee39f3d41..4d969d1539c 100644 --- 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 index 850a78eb435..00000000000 --- 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 1b32ac45954..1411165bf63 100644 --- 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 index 00000000000..63fdcac27db --- /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 index 00000000000..81ca11b948c --- /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 index 7d79bf31816..00000000000 --- 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 -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 -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<(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, R4 ADD R1->R2, R3, R4 ADD R1, R2, R3 - ADD R(1)<(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 index 37944bc75cd..00000000000 --- 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 2c8720bd3b9..22d430631cf 100644 --- 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 index 9263a7ba4b5..00000000000 --- 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 4112b4b1201..12330a2edb9 100644 --- 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 index 2a5d1753338..00000000000 --- 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 46c1ee6d95d..c46c6b2f5a5 100644 --- 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 89bc6f3a8c2..9f3c3bfc1da 100644 --- 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 db0e28e2e59..f48050c1378 100644 --- 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 16b7cd131bd..67ab7042ffe 100644 --- 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 5d65217c613..45a3765d3ee 100644 --- 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 e60318dc882..79cf6e07f7f 100644 --- 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 56b62d24d64..563ccb30523 100644 --- 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 7408680b5a1..dbd8db16e54 100644 --- 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 ac55d4fd5d8..60b93ef8050 100644 --- 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 9a1e70f43de..e4ce9c796be 100644 --- 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 d5183234b92..df0d8cb7fbd 100644 --- 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 3279f4c6b07..054cf736561 100644 --- 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 35a492923fa..3f8fdce83bb 100644 --- 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 4cd696a0a17..156b8681094 100644 --- 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 ea2eb77470e..c81bd40864a 100644 --- 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 6a8edaf6d25..a1f925ed0ba 100644 --- 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 50c7521831e..6d12f750739 100644 --- 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 35c7cc4f2a7..8f741a636b1 100644 --- 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 c6d77f7884f..d3845947225 100644 --- 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 0507841c6b1..a804ccd277c 100644 --- 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 7ee067a003d..bf10f4f3e91 100644 --- 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 5e72ada9387..7190f599d68 100644 --- 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 96e6049dad0..3f2165bd38a 100644 --- 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 074dd8b2b12..342edee50d9 100644 --- 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 f5d5e4f4f0b..a90c2061edb 100644 --- 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 e3f98ce8319..7fdd9623bd0 100644 --- 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 3ba0c7d95bc..d75a16354cb 100644 --- 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 d3e1e5ecbba..f459483cce3 100644 --- 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 486d4698a19..4ee4043af75 100644 --- 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 dca7a7f8323..162acd25552 100644 --- 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 f3d1a9557a4..2e6df2c2f87 100644 --- 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 f271a876093..282cb79e313 100644 --- 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 0807a62a8d0..40dc4605c9b 100644 --- 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 ea59d4605e7..459361cf48e 100644 --- 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 f163505fd0c..ca7b0cfdcad 100644 --- 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 392899cf5f3..1875eae4181 100644 --- 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 8d0f86681f2..4577ed79259 100644 --- 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 - 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[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:] +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[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[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 fc79b902a26..0284bbfe8ab 100644 --- 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 d83ab24ab8a..a5c80cea3b6 100644 --- 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 69f9b578590..ffaead7ba0d 100644 --- 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 8ffa656208a..74c22497029 100644 --- 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 a34cf3cac86..6d34978d5a0 100644 --- 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 75612503b1e..bdfa0563c3d 100644 --- 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,17 +505,24 @@ 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 != "" { - ldshlibsyms(Ctxt.Library[i].Shlib) - } else { + 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) + } + } + if Linkmode == LinkAuto { if iscgo && externalobj { Linkmode = LinkExternal @@ -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 319e8504670..808d377f8a0 100644 --- 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 8807952b48a..1985a86fe01 100644 --- 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 5436c5bf04b..a16e864cad2 100644 --- 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 index 00000000000..276aea96193 --- /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 beeb642f2ad..c5faa36e897 100644 --- 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 1cfa982df4b..f6cc3865061 100644 --- 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 184ea9d4d62..a80ebd36931 100644 --- 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 index 00000000000..1435b701460 --- /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 37eaf1ab3e7..5c5f415c88d 100644 --- 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 0a3e6acee96..ee022b803ae 100644 --- 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 c1d1331bde2..4bedd7682d3 100644 --- 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 bba5a8843a0..740fd9d6e7c 100644 --- 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 1fab282b408..342875e190c 100644 --- 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 b5a17f0fc1a..d8e7cb77af3 100644 --- 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 70ff8771720..45f4157318a 100644 --- 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 61aac8fe5f2..7312af08b57 100644 --- 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 4603102526f..376931e1981 100644 --- 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 630581047a2..310814df71c 100644 --- 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 de1ab0267a4..dbd96c07a31 100644 --- 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 942d3fd5f73..f7c4a173785 100644 --- 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 564d0649b2f..4fe0c629386 100644 --- 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 faac5d4e2e7..3106d229da6 100644 --- 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 cfad71e0295..8939dc8baf9 100644 --- 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 9c1aa7920e3..fbaa805712b 100644 --- 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 c41d001d8f1..f61c138c1d9 100644 --- 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 2e17d3f4bb6..69d78066cd6 100644 --- 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 cd530f16cd0..c4faccc7a8d 100644 --- 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 6fe8fea110b..e22cc66dbfc 100644 --- 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 4dba352a4fa..54411caeca8 100644 --- 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 7f203d878f5..0849427b85c 100644 --- 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 3967ad614f4..2e62c00d5db 100644 --- 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 7c1c91662fd..a136dc99a65 100644 --- 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) { - 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) - } + type testCase struct { + in string + want uint64 + wantErr string } - _, err := parseHexUint([]byte("bogus")) - if err == nil { - t.Error("expected error on bogus input") + 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++ { + tests = append(tests, testCase{in: fmt.Sprintf("%x", i), want: i}) + } + 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 16c5bb43ac4..8cdab02af5a 100644 --- 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 b4bf09aa9bd..d8a53400cf2 100644 --- 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 f8cad802d49..384b453ce0a 100644 --- 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 2ec106927b9..5e3b6084ae3 100644 --- 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 fc0ae36b519..41df906cf2d 100644 --- 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 3b2a5f978e2..8cb89a4220b 100644 --- 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 677a5f57fd4..439496ac81d 100644 --- 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 6dcfc2190e0..cd62b4373eb 100644 --- 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 e59dcd52d3d..095a339e02c 100644 --- 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 3ea75637ac5..1a93e3496ed 100644 --- 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 c31b18980ed..d3f8487bd7c 100644 --- 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 389a8eb14cb..869a28a8a4e 100644 --- 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 cac032c3703..5094812a054 100644 --- 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 09fbc952e09..07894a3a722 100644 --- 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 be27725680a..a3bc6c4d409 100644 --- 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 #include #include "libcgo.h" diff --git a/src/runtime/cgo/gcc_android_386.c b/src/runtime/cgo/gcc_android_386.c index a82d7d01b0b..db1d48aaaed 100644 --- 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 /* for strerror */ #include #include diff --git a/src/runtime/cgo/gcc_android_amd64.c b/src/runtime/cgo/gcc_android_amd64.c index 4cea4597485..17d88cec911 100644 --- 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 /* for strerror */ #include #include diff --git a/src/runtime/cgo/gcc_android_arm.c b/src/runtime/cgo/gcc_android_arm.c index 85cd244c02c..67cb5a89528 100644 --- 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 #include #include diff --git a/src/runtime/cgo/gcc_android_arm64.c b/src/runtime/cgo/gcc_android_arm64.c index 5d4cefee607..acf37355eb1 100644 --- 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 #include #include diff --git a/src/runtime/cgo/gcc_darwin_386.c b/src/runtime/cgo/gcc_darwin_386.c index 6668ba4a213..a94e5ee48d0 100644 --- 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 /* for strerror */ #include #include diff --git a/src/runtime/cgo/gcc_darwin_amd64.c b/src/runtime/cgo/gcc_darwin_amd64.c index dc679acab9d..b70c83345f5 100644 --- 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 /* for strerror */ #include #include diff --git a/src/runtime/cgo/gcc_darwin_arm.c b/src/runtime/cgo/gcc_darwin_arm.c index c303b914ccb..c0ce449f134 100644 --- 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 #include #include diff --git a/src/runtime/cgo/gcc_darwin_arm64.c b/src/runtime/cgo/gcc_darwin_arm64.c index b64a063b982..1ba00b02fb5 100644 --- 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 #include #include diff --git a/src/runtime/cgo/gcc_dragonfly_amd64.c b/src/runtime/cgo/gcc_dragonfly_amd64.c index f79f652e466..9d02add92df 100644 --- 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 #include #include @@ -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 21c1acfaad1..c931b79abf3 100644 --- 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 diff --git a/src/runtime/cgo/gcc_freebsd_386.c b/src/runtime/cgo/gcc_freebsd_386.c index 074418f77d3..2afdf2088fd 100644 --- 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 #include #include diff --git a/src/runtime/cgo/gcc_freebsd_amd64.c b/src/runtime/cgo/gcc_freebsd_amd64.c index f79f652e466..bf71d4c09d5 100644 --- 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 #include #include diff --git a/src/runtime/cgo/gcc_freebsd_arm.c b/src/runtime/cgo/gcc_freebsd_arm.c index 2a86a91174e..60bca55d84b 100644 --- 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 #include #include diff --git a/src/runtime/cgo/gcc_libinit.c b/src/runtime/cgo/gcc_libinit.c index c3e94f58d2c..5b9558aabc8 100644 --- 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 82413a5a65e..18ccf935727 100644 --- 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 7e5b6468a6f..13904eede21 100644 --- 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 #include diff --git a/src/runtime/cgo/gcc_libinit_windows.c b/src/runtime/cgo/gcc_libinit_windows.c index 7e5b6468a6f..13904eede21 100644 --- 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 #include diff --git a/src/runtime/cgo/gcc_linux_386.c b/src/runtime/cgo/gcc_linux_386.c index 8fb7130e31b..2457eb38063 100644 --- 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 #include #include diff --git a/src/runtime/cgo/gcc_linux_amd64.c b/src/runtime/cgo/gcc_linux_amd64.c index 51ca6446cf1..5113a769b5f 100644 --- 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 #include #include // strerror diff --git a/src/runtime/cgo/gcc_linux_arm.c b/src/runtime/cgo/gcc_linux_arm.c index 7d4b4d6d4f4..ce940fee455 100644 --- 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 #include #include diff --git a/src/runtime/cgo/gcc_linux_arm64.c b/src/runtime/cgo/gcc_linux_arm64.c index ea11cf53131..babbd50e85f 100644 --- 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 #include #include diff --git a/src/runtime/cgo/gcc_linux_ppc64x.c b/src/runtime/cgo/gcc_linux_ppc64x.c index b1762957a2e..1264ab59596 100644 --- 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 diff --git a/src/runtime/cgo/gcc_mmap.c b/src/runtime/cgo/gcc_mmap.c index 10d589fa288..f2bcc9866b2 100644 --- 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 diff --git a/src/runtime/cgo/gcc_netbsd_386.c b/src/runtime/cgo/gcc_netbsd_386.c index 2505e6dc7cf..4355bd0cae3 100644 --- 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 #include #include @@ -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 8f646502d7a..00e0667dbe3 100644 --- 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 #include #include @@ -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 7a98c0de24b..32bc85b7c64 100644 --- 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 #include #include @@ -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 c4be9a00969..5f6d4cbb936 100644 --- 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 #include #include diff --git a/src/runtime/cgo/gcc_openbsd_amd64.c b/src/runtime/cgo/gcc_openbsd_amd64.c index 8522cd48c4a..42265671d7d 100644 --- 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 #include #include diff --git a/src/runtime/cgo/gcc_setenv.c b/src/runtime/cgo/gcc_setenv.c index ca29dcb05f2..c976ac3d37c 100644 --- 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 e36fe26bb10..295c5623f07 100644 --- 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 b26315f10d7..edb55f3030d 100644 --- 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 98a1a8be532..5a01e0826e3 100644 --- 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 #include #include diff --git a/src/runtime/cgo/gcc_util.c b/src/runtime/cgo/gcc_util.c index 143734e94b0..d5efec396bd 100644 --- 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 acd038ccd6f..e02991af218 100644 --- 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 #include diff --git a/src/runtime/cgo/gcc_windows_amd64.c b/src/runtime/cgo/gcc_windows_amd64.c index ce7e06b3dfe..1b3e8e32836 100644 --- 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 #include diff --git a/src/runtime/cgo_mmap.go b/src/runtime/cgo_mmap.go index ef5501ca5f7..c0396bdde51 100644 --- 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 210d1862f95..66115fd8b49 100644 --- 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 a7af7eff285..1a012eb6ef1 100644 --- 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 dfceba33765..4d1da1c1dfb 100644 --- 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 18001bf85ec..b520c68df08 100644 --- 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 5e78037df60..c257d59b30b 100644 --- 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 92b811830c3..94301c6dc7f 100644 --- 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 eb7231aec22..fc73bbfbe15 100644 --- 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") + ok = true + r := p - 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 + // 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 e9e0b6aa1ce..5c00407b2fc 100644 --- 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 a739ef5a724..bf3e1ccb839 100644 --- 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 42199020e51..eab8eb87024 100644 --- 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 d32b31578d0..7d677cb64e6 100644 --- 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 24bf9457e36..f7c1a46805a 100644 --- 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 } - f() - StopCPUProfile() + + // 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) + } + } + + 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 a7e94a9c1d4..d1f5088b502 100644 --- 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 f3e90bcbd76..9e5960bd2af 100644 --- 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() - if nstk := strings.Count(string(buf), "goroutine "); n != nstk { - t.Fatalf("NumGoroutine=%d, but found %d goroutines in stack dump", n, nstk) + n := runtime.NumGoroutine() + buf = buf[:runtime.Stack(buf, true)] + + 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 a9f9f0fbd5d..0c71a019dd5 100644 --- 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 6898e749007..748f33883bd 100644 --- 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 3b0b8ec2893..0494493b2e9 100644 --- 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 54c4686f799..917fe89d388 100644 --- 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 664c1180c42..a6150a77ee9 100644 --- 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 fa073f19adb..928d1eca20a 100644 --- 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 f8ccd41b1d3..dd04bda04ba 100644 --- 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 318a5532e52..150a25520ad 100644 --- 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 c516ef2da81..ad3dca444a8 100644 --- 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 d1b94e1bfdc..4e4d793c43b 100644 --- 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 35a1b5dd003..fb21f1155ab 100644 --- 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 ffe75905263..3f8f6968c2a 100644 --- 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 58956383a3b..805c34f4834 100644 --- 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 a5816609408..8ec34fd343b 100644 --- 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 6c60091bc54..df8c95f8c89 100644 --- 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 c8e53a27cf0..c56743933f9 100644 --- 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 752792f41bf..532fa4aa229 100644 --- 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 index 00000000000..e540318bb28 --- /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 index 00000000000..b56ed73be9d --- /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 index 00000000000..4fdbf76b903 --- /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 index 00000000000..bf030516198 --- /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 index 00000000000..bcc6a63c207 --- /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 index 00000000000..5247599d497 --- /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