From 5e7110b92b959d22eba421953beaf1de8580f8f5 Mon Sep 17 00:00:00 2001 From: OneOfOne Date: Fri, 15 Jan 2016 19:24:44 +0200 Subject: [PATCH 001/128] cmd/link: fix elf64phdr to allow using upx (and other broken ELF loaders). The linker already applies the fix for elf32, so this just extends it to elf64. Inspired by https://github.com/pwaller/goupx Fixes #13974 Change-Id: I65d92b5be9590657060a0e8e80ff5b86ba40017f Reviewed-on: https://go-review.googlesource.com/18690 Reviewed-by: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gobot Gobot --- src/cmd/link/internal/ld/elf.go | 30 ++++++++++++++++++++---------- 1 file changed, 20 insertions(+), 10 deletions(-) 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_) From 92ba69d216e6b840b02ae4ecdc7fb425a94473b2 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Fri, 15 Jan 2016 14:52:06 -0800 Subject: [PATCH 002/128] cmd/compile: set importpkg.Direct correctly when using binary imports Fixes #13977. Change-Id: Icf54b4d2d746d30da207d1e17c975d18188b1cf8 Reviewed-on: https://go-review.googlesource.com/18702 Run-TryBot: Robert Griesemer TryBot-Result: Gobot Gobot Reviewed-by: Alan Donovan --- src/cmd/compile/internal/gc/lex.go | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/cmd/compile/internal/gc/lex.go b/src/cmd/compile/internal/gc/lex.go index fb30d585270..01eb3a56560 100644 --- a/src/cmd/compile/internal/gc/lex.go +++ b/src/cmd/compile/internal/gc/lex.go @@ -843,6 +843,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)) From 7ce2402baeac8a344af6868b9cee79bc33e3e3fb Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 19 Jan 2016 13:14:03 -0800 Subject: [PATCH 003/128] cmd/compile: don't crash on invalid labeled statement Fixes #14006. Change-Id: Ia819073677ad6993c02255e23760ee21598427b4 Reviewed-on: https://go-review.googlesource.com/18736 Run-TryBot: Robert Griesemer Reviewed-by: Russ Cox TryBot-Result: Gobot Gobot --- src/cmd/compile/internal/gc/parser.go | 7 ++- test/fixedbugs/issue14006.go | 64 +++++++++++++++++++++++++++ 2 files changed, 70 insertions(+), 1 deletion(-) create mode 100644 test/fixedbugs/issue14006.go diff --git a/src/cmd/compile/internal/gc/parser.go b/src/cmd/compile/internal/gc/parser.go index 3279f4c6b07..282e855b37e 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 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 From d9b32f0c7d327f4fc165eb1fb9e76ac97b314c95 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Tue, 19 Jan 2016 13:52:51 -0800 Subject: [PATCH 004/128] cmd/compile: add VARLIVE to opnames list Change-Id: Ie8cb7c7428ae9026c11643b22f9ecf7977e25f5f Reviewed-on: https://go-review.googlesource.com/18737 Reviewed-by: Russ Cox --- src/cmd/compile/internal/gc/opnames.go | 1 + 1 file changed, 1 insertion(+) diff --git a/src/cmd/compile/internal/gc/opnames.go b/src/cmd/compile/internal/gc/opnames.go index 9134bd43329..06096437bf8 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", From df2a9e4a337a4feda8981433639cbddeb8216d37 Mon Sep 17 00:00:00 2001 From: Michael Hudson-Doyle Date: Tue, 19 Jan 2016 16:27:14 +1300 Subject: [PATCH 005/128] runtime/race: fix test so it compiles I'm not sure what the convert function was intended to be. Fixes #14011 Change-Id: I29d905bc1827936b9433b20b13b7a0b0ac5f502e Reviewed-on: https://go-review.googlesource.com/18712 Reviewed-by: Ian Lance Taylor Run-TryBot: Ian Lance Taylor TryBot-Result: Gobot Gobot --- src/runtime/race/testdata/issue12225_test.go | 7 +++++++ 1 file changed, 7 insertions(+) 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]))) From 53958468907a349662bf49d349e1c63bea25861f Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Tue, 19 Jan 2016 14:17:29 -0800 Subject: [PATCH 006/128] cmd/compile: don't print (empty) package name in errors referring to built-ins Fixes #14010. Change-Id: Idfd4b063eecf453fe00f3e798099023707a65963 Reviewed-on: https://go-review.googlesource.com/18738 Reviewed-by: Russ Cox Run-TryBot: Robert Griesemer --- src/cmd/compile/internal/gc/fmt.go | 2 +- test/fixedbugs/issue14010.go | 15 +++++++++++++++ 2 files changed, 16 insertions(+), 1 deletion(-) create mode 100644 test/fixedbugs/issue14010.go diff --git a/src/cmd/compile/internal/gc/fmt.go b/src/cmd/compile/internal/gc/fmt.go index 4da60f4c895..64b6e36758d 100644 --- a/src/cmd/compile/internal/gc/fmt.go +++ b/src/cmd/compile/internal/gc/fmt.go @@ -419,7 +419,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/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" +} From 97266969d8f9b0b2fd6c37121a3f0d52872efced Mon Sep 17 00:00:00 2001 From: Shenghou Ma Date: Mon, 18 Jan 2016 22:42:40 -0500 Subject: [PATCH 007/128] cmd/dist: pass -tags race to go list in -race mode so that runtime/race tests are included in the race builder. Update #14011. Change-Id: I04ac6e47366fdb1fe84ba89da556c6d38f7d4a47 Reviewed-on: https://go-review.googlesource.com/18686 Run-TryBot: Minux Ma TryBot-Result: Gobot Gobot Reviewed-by: Brad Fitzpatrick --- src/cmd/dist/test.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) 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") } From cd9fc3ebfbdb129570317b3a2537975851370c7a Mon Sep 17 00:00:00 2001 From: Michael Hudson-Doyle Date: Wed, 20 Jan 2016 15:31:26 +1300 Subject: [PATCH 008/128] cmd/link: allow symbols from .a files to override those from .so files https://golang.org/s/execmodes defines rules for how multiple codes of a go package work when they end up in the address space of a single process, but currently the linker blows up in this situation. Fix that by loading all .a files before any .so files and ignoring duplicate symbols found when loading shared libraries. I know this is very very late for 1.6 but at least it should clearly not have any effect when shared libraries are not in use. Change-Id: I512ac912937e7502ff58eb5628b658ecce3c38e5 Reviewed-on: https://go-review.googlesource.com/18714 Reviewed-by: Ian Lance Taylor Run-TryBot: Ian Lance Taylor --- misc/cgo/testshared/shared_test.go | 12 +++++++ misc/cgo/testshared/src/explicit/explicit.go | 9 +++++ misc/cgo/testshared/src/implicit/implicit.go | 5 +++ .../testshared/src/implicitcmd/implicitcmd.go | 10 ++++++ src/cmd/link/internal/ld/lib.go | 36 +++++++++---------- 5 files changed, 54 insertions(+), 18 deletions(-) create mode 100644 misc/cgo/testshared/src/explicit/explicit.go create mode 100644 misc/cgo/testshared/src/implicit/implicit.go create mode 100644 misc/cgo/testshared/src/implicitcmd/implicitcmd.go 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/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go index 75612503b1e..a23a437e3d0 100644 --- a/src/cmd/link/internal/ld/lib.go +++ b/src/cmd/link/internal/ld/lib.go @@ -504,17 +504,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 @@ -1458,18 +1465,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) From e8e1928bd22339dcdbfde17778cfd976184bb377 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Wed, 20 Jan 2016 22:41:52 +0000 Subject: [PATCH 009/128] net/http: update http2 to check header values, move from vendor to internal Updates x/net/http2 to git rev b2ed34f for https://golang.org/cl/18727 Updates #14029 (fixes it enough for Go 1.6) Fixes #13961 Change-Id: Id301247545507671f4e79df0e7c6ec9c421d5a7c Reviewed-on: https://go-review.googlesource.com/18728 Run-TryBot: Brad Fitzpatrick TryBot-Result: Gobot Gobot Reviewed-by: Andrew Gerrand --- src/go/build/build_test.go | 1 + src/go/build/deps_test.go | 2 +- .../golang.org/x/net/http2/hpack/encode.go | 0 .../x/net/http2/hpack/encode_test.go | 0 .../golang.org/x/net/http2/hpack/hpack.go | 0 .../x/net/http2/hpack/hpack_test.go | 0 .../golang.org/x/net/http2/hpack/huffman.go | 0 .../golang.org/x/net/http2/hpack/tables.go | 0 src/net/http/h2_bundle.go | 151 ++++++++++++++++-- src/vendor/README | 8 + 10 files changed, 151 insertions(+), 11 deletions(-) rename src/{vendor => internal}/golang.org/x/net/http2/hpack/encode.go (100%) rename src/{vendor => internal}/golang.org/x/net/http2/hpack/encode_test.go (100%) rename src/{vendor => internal}/golang.org/x/net/http2/hpack/hpack.go (100%) rename src/{vendor => internal}/golang.org/x/net/http2/hpack/hpack_test.go (100%) rename src/{vendor => internal}/golang.org/x/net/http2/hpack/huffman.go (100%) rename src/{vendor => internal}/golang.org/x/net/http2/hpack/tables.go (100%) create mode 100644 src/vendor/README 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/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/h2_bundle.go b/src/net/http/h2_bundle.go index cd530f16cd0..bdbdadb5b28 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" @@ -37,8 +38,6 @@ import ( "strings" "sync" "time" - - "golang.org/x/net/http2/hpack" ) // ClientConnPool manages a pool of HTTP/2 client connections. @@ -2065,13 +2064,60 @@ 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-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' { return false } } @@ -2202,6 +2248,86 @@ 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, +} + // 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) @@ -2741,7 +2867,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 +2897,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 +2917,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: @@ -5697,7 +5825,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 +5841,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 +5853,10 @@ func (rl *http2clientConnReadLoop) checkHeaderField(f hpack.HeaderField) bool { return false } } else { + if !http2validHeaderFieldName(f.Name) { + rl.reqMalformed = http2errInvalidHeaderFieldName + return false + } rl.sawRegHeader = true } 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. From 33a784e1f7fc56ecea696ab07558ca220e3bef0f Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Mon, 18 Jan 2016 15:40:47 -0800 Subject: [PATCH 010/128] cmd/go: document PackageError in go list output Fixes #14007. Change-Id: I1f73dfccb466d8fd00efbd8c92a31ac538bf5988 Reviewed-on: https://go-review.googlesource.com/18731 Reviewed-by: Brad Fitzpatrick --- src/cmd/go/alldocs.go | 8 ++++++++ src/cmd/go/list.go | 8 ++++++++ 2 files changed, 16 insertions(+) diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go index ea2eb77470e..5db4bc6beca 100644 --- a/src/cmd/go/alldocs.go +++ b/src/cmd/go/alldocs.go @@ -603,6 +603,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/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: From f8f4cfa5beb64f4413c75400b5ad6d979f65451f Mon Sep 17 00:00:00 2001 From: Olivier Poitrey Date: Wed, 20 Jan 2016 22:53:50 -0800 Subject: [PATCH 011/128] net/http: make Client propagate Request.Cancel over redirected requests On HTTP redirect, the HTTP client creates a new request and don't copy over the Cancel channel. This prevents any redirected request from being cancelled. Fixes #14053 Change-Id: I467cdd4aadcae8351b6e9733fc582b7985b8b9d3 Reviewed-on: https://go-review.googlesource.com/18810 Reviewed-by: Brad Fitzpatrick Run-TryBot: Brad Fitzpatrick --- src/net/http/client.go | 1 + src/net/http/client_test.go | 18 +++++++++++++++++- 2 files changed, 18 insertions(+), 1 deletion(-) 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 { From 754216d1d7642e8f254d0c8b8cd47ce3426ea051 Mon Sep 17 00:00:00 2001 From: Rob Pike Date: Wed, 20 Jan 2016 16:08:31 -0800 Subject: [PATCH 012/128] text/template: fix documentation for pipelines The header was in the wrong place, so the definition of a pipeline was not in the section labeled "Pipelines". Fixes #13972 Change-Id: Ibca791a4511ca112047b57091c391f6e959fdd78 Reviewed-on: https://go-review.googlesource.com/18775 Reviewed-by: Brad Fitzpatrick Reviewed-by: Andrew Gerrand --- src/text/template/doc.go | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) 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 From b203f88c7f0b81043a3f387136147d8193a0a8b8 Mon Sep 17 00:00:00 2001 From: Adam Langley Date: Tue, 19 Jan 2016 08:27:10 -0800 Subject: [PATCH 013/128] crypto/tls: note in comment that Certificate.Leaf is nil after parsing. LoadX509KeyPair and X509KeyPair don't retain the parsed form of certificates in their return value because it's generally not needed. This change makes that clear in the comment. See https://groups.google.com/d/msg/golang-dev/VResvFj2vF8/Wt6WkVT2AwAJ Change-Id: Ibb759cd6e84c00f4450a012992088422c0546638 Reviewed-on: https://go-review.googlesource.com/18734 Reviewed-by: Russ Cox --- src/crypto/tls/tls.go | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) 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 } From 489f65b52ad28c2a6f4f2dc58a3d939e9a77be47 Mon Sep 17 00:00:00 2001 From: Tim Ebringer Date: Mon, 18 Jan 2016 21:33:25 +1100 Subject: [PATCH 014/128] net: improve netsh usage in Windows unit tests The TestInterfaceAddrsWithNetsh Windows unit test parses and compares the output of the "netsh" command against more low level Windows API calls. In at least two cases, some quirks of netsh cause these comparisons to fail. One example appears to be wi-fi adapters. After a reboot, before it has been allowed to connect to a network, netsh for IPv4 will not show an address, whereas netsh for IPv6 will. If the interface is allowed to connect, and then disconnected, netsh for IPv4 now shows an address and the test will pass. The fix is to not compare netsh output if the interface is down. A related issue is that the IPv6 version of "netsh" can return an IPv4-embedded IPv6 address where the IPv4 component of the address is in decimal form, whilst the test is expecting hexadecimal form. For example, output might be: Address fe80::5efe:192.168.1.7%6 Parameters ... Whilst this is valid notation, the fix is to recognise this format in the "netsh" output and re-parse the address into the all-hexadecimal representation that the test is expecting. Fixes #13981 Change-Id: Ie8366673f4d43d07bad80d6d5d1d6e33f654b6cc Reviewed-on: https://go-review.googlesource.com/18711 Reviewed-by: Alex Brainman Run-TryBot: Alex Brainman TryBot-Result: Gobot Gobot --- src/net/net_windows_test.go | 15 +++++++++++++-- 1 file changed, 13 insertions(+), 2 deletions(-) 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 { From 4c4476c297e0a43bf92e8303da369cdc18e5745c Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Thu, 21 Jan 2016 12:38:05 -0800 Subject: [PATCH 015/128] runtime: on NetBSD and DragonFly drop signal stack in new thread On NetBSD and DragonFly a newly created thread inherits the signal stack of the creating thread. This breaks horribly if both threads get a signal at the same time. Fix this by dropping the signal stack in the newly created thread. The right signal stack will then get installed later. Note that cgo code that calls pthread_create will have the wrong, duplicated, signal stack in the newly created thread. I don't see any way to fix that in Go. People using cgo to call pthread_create will have to be aware of the problem. Fixes #13945. Fixes #13947. Change-Id: I0c7bd2cdf9ada575d57182ca5e9523060de34931 Reviewed-on: https://go-review.googlesource.com/18814 TryBot-Result: Gobot Gobot Reviewed-by: Brad Fitzpatrick Reviewed-by: Russ Cox --- src/runtime/cgo/gcc_dragonfly_amd64.c | 12 ++++++++++++ src/runtime/cgo/gcc_netbsd_386.c | 12 ++++++++++++ src/runtime/cgo/gcc_netbsd_amd64.c | 12 ++++++++++++ src/runtime/cgo/gcc_netbsd_arm.c | 12 ++++++++++++ src/runtime/os1_netbsd.go | 15 ++++++++++++++- src/runtime/sys_dragonfly_amd64.s | 12 ++++++++++++ 6 files changed, 74 insertions(+), 1 deletion(-) diff --git a/src/runtime/cgo/gcc_dragonfly_amd64.c b/src/runtime/cgo/gcc_dragonfly_amd64.c index f79f652e466..f41b9b408a3 100644 --- a/src/runtime/cgo/gcc_dragonfly_amd64.c +++ b/src/runtime/cgo/gcc_dragonfly_amd64.c @@ -56,6 +56,7 @@ static void* threadentry(void *v) { ThreadStart ts; + stack_t ss; ts = *(ThreadStart*)v; free(v); @@ -65,6 +66,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_netbsd_386.c b/src/runtime/cgo/gcc_netbsd_386.c index 2505e6dc7cf..6fc7a122b4b 100644 --- a/src/runtime/cgo/gcc_netbsd_386.c +++ b/src/runtime/cgo/gcc_netbsd_386.c @@ -55,6 +55,7 @@ static void* threadentry(void *v) { ThreadStart ts; + stack_t ss; ts = *(ThreadStart*)v; free(v); @@ -64,6 +65,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..f0ecfac575a 100644 --- a/src/runtime/cgo/gcc_netbsd_amd64.c +++ b/src/runtime/cgo/gcc_netbsd_amd64.c @@ -56,6 +56,7 @@ static void* threadentry(void *v) { ThreadStart ts; + stack_t ss; ts = *(ThreadStart*)v; free(v); @@ -65,6 +66,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..3567aaae725 100644 --- a/src/runtime/cgo/gcc_netbsd_arm.c +++ b/src/runtime/cgo/gcc_netbsd_arm.c @@ -57,10 +57,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/os1_netbsd.go b/src/runtime/os1_netbsd.go index 42199020e51..9ab39ba97d9 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() } 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) From 123510bf8302ecacc1cc73e4255f6b72e7fcb9a7 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Thu, 21 Jan 2016 12:43:34 -0800 Subject: [PATCH 016/128] runtime: save context value in NetBSD sigtramp MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit On NetBSD a signal handler returns to the kernel by calling the setcontext system call with the context passed to the signal handler. The implementation of runtime·sigreturn_tramp for amd64, copied from the NetBSD libc, expects that context address to be in r15. That works in the NetBSD libc because r15 is preserved across the call to the signal handler. It fails in the Go library because r15 is not preserved. There are various ways to fix this; this one uses the simple approach, essentially identical to the one in the NetBSD libc, of preserving r15 across the signal handler proper. Looking at the code for 386 and arm suggests that they are OK. However, I have not actually tested them. Update #14052. Change-Id: I2b516b1d05fe5d3b8911e65ca761d621dc37fa1b Reviewed-on: https://go-review.googlesource.com/18815 Run-TryBot: Ian Lance Taylor TryBot-Result: Gobot Gobot Reviewed-by: Brad Fitzpatrick --- src/runtime/sys_netbsd_amd64.s | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) 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 From c7f5831fa9277edebb863ab11c9527fb09637ce9 Mon Sep 17 00:00:00 2001 From: David Symonds Date: Fri, 22 Jan 2016 10:06:08 +1100 Subject: [PATCH 017/128] lib/time: update to IANA release 2015g. Change-Id: Id82209dc313fa6b54e623eb325412737e7a055fe Reviewed-on: https://go-review.googlesource.com/18794 Reviewed-by: Andrew Gerrand --- lib/time/update.bash | 5 +++-- lib/time/zoneinfo.zip | Bin 359824 -> 360617 bytes 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/lib/time/update.bash b/lib/time/update.bash index 3ef1df582cf..3ffadc2ab4c 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=2015g +DATA=2015g set -e rm -rf work diff --git a/lib/time/zoneinfo.zip b/lib/time/zoneinfo.zip index 73c30b45970f489c9b8b7bea0f1ccdfa958b5d49..740d81988b194a75737abfae5c1005e5bf2a6d53 100644 GIT binary patch delta 46237 zcmb`wcYIVu*EpVg_Xa`<1QJp<1wuy%At1em&{GH`^pY&ek}N43Hd!DD0!k4QP3gt*D2NzTkRl4|qaXs`Gc$MZJ#+W+{{H##dB^AdWX_y9ea@VjJG

uYG<4D?wt*IqKVSgRkQvd7abyE9^s`isuPsQfY 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 z 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 HKlA%PW5|*` From 0760023960fc9f1012e6bac277b886cac1c1bae9 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Thu, 21 Jan 2016 15:18:23 -0800 Subject: [PATCH 018/128] runtime: skip TestSignalExitStatus on NetBSD It doesn't work and I don't know why. Update #14063. Change-Id: I42735012cf6247eca5336f29fcf713e08c8477f8 Reviewed-on: https://go-review.googlesource.com/18817 Run-TryBot: Ian Lance Taylor TryBot-Result: Gobot Gobot Reviewed-by: Brad Fitzpatrick --- src/runtime/crash_unix_test.go | 4 ++++ 1 file changed, 4 insertions(+) diff --git a/src/runtime/crash_unix_test.go b/src/runtime/crash_unix_test.go index a7af7eff285..5284a37b0f1 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": + t.Skip("skipping on NetBSD; see https://golang.org/issue/14063") + } exe, err := buildTestProg(t, "testprog") if err != nil { t.Fatal(err) From 445c6855fc65d144d32330c130fde91c774368ef Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 21 Jan 2016 16:36:36 -0800 Subject: [PATCH 019/128] cmd/compile: remove unused (dead) fields Change-Id: I4816a788e7b89b76dc70d05f4b176e99684d0680 Reviewed-on: https://go-review.googlesource.com/18830 Run-TryBot: Robert Griesemer TryBot-Result: Gobot Gobot Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/gc/lex.go | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/src/cmd/compile/internal/gc/lex.go b/src/cmd/compile/internal/gc/lex.go index 01eb3a56560..8d1d2e25944 100644 --- a/src/cmd/compile/internal/gc/lex.go +++ b/src/cmd/compile/internal/gc/lex.go @@ -932,13 +932,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 ( From a4599efcfb1ca5345efbb4c185ac0094b312f472 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Thu, 21 Jan 2016 16:48:14 -0800 Subject: [PATCH 020/128] cmd/compile: update vendored copy of math/big - obtained by running sh vendor.bash - contains updated tests and some bug fixes for Montgomery mult. (not used by compiler) - for consistency of math/big versions only Change-Id: Ib47e48d5b7f6d0e05d7837b1bc74bdb03f2b094e Reviewed-on: https://go-review.googlesource.com/18831 Run-TryBot: Robert Griesemer TryBot-Result: Gobot Gobot Reviewed-by: Brad Fitzpatrick --- src/cmd/compile/internal/big/int.go | 2 +- src/cmd/compile/internal/big/int_test.go | 27 ++++++++++- src/cmd/compile/internal/big/nat.go | 58 ++++++++++++++---------- src/cmd/compile/internal/big/nat_test.go | 6 +++ 4 files changed, 67 insertions(+), 26 deletions(-) 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) { From 1b6d55acab9199e09f9134ff3ac359647767f741 Mon Sep 17 00:00:00 2001 From: Shenghou Ma Date: Thu, 21 Jan 2016 16:45:36 -0500 Subject: [PATCH 021/128] cmd/internal/obj/mips, cmd/internal/obj: reduce MIPS register space Change-Id: I43458ce0e78ffc3d0943d28dc8df8e1c9e4cf679 Reviewed-on: https://go-review.googlesource.com/18821 Reviewed-by: Ian Lance Taylor Run-TryBot: Minux Ma TryBot-Result: Gobot Gobot --- src/cmd/internal/obj/mips/a.out.go | 6 ++++-- src/cmd/internal/obj/mips/list0.go | 2 +- src/cmd/internal/obj/util.go | 2 +- 3 files changed, 6 insertions(+), 4 deletions(-) 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 51101c5ce0b..5103299526a 100644 --- a/src/cmd/internal/obj/util.go +++ b/src/cmd/internal/obj/util.go @@ -529,7 +529,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 From 2a09a68dd951a563b2e6fb6d0d3b5a77ec9e67d5 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Wed, 13 Jan 2016 20:14:03 -0500 Subject: [PATCH 022/128] unsafe: document valid uses of Pointer Add docs for valid uses of Pointer. Then document change made for #13372 in CL 18584. Fixes #8994. Change-Id: Ifba71e5aeafd11f684aed0b7ddacf3c8ec07c580 Reviewed-on: https://go-review.googlesource.com/18640 Reviewed-by: Alan Donovan Reviewed-by: Robert Griesemer Reviewed-by: Ian Lance Taylor Reviewed-by: Rob Pike Reviewed-by: Austin Clements Reviewed-by: Rick Hudson --- src/unsafe/unsafe.go | 157 +++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 152 insertions(+), 5 deletions(-) diff --git a/src/unsafe/unsafe.go b/src/unsafe/unsafe.go index 752792f41bf..34ca77965b2 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 uintptr. +// +// 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 From 4f40182240e6af76dcb2fbc307d69133e58cea19 Mon Sep 17 00:00:00 2001 From: Mikio Hara Date: Thu, 21 Jan 2016 17:22:30 +0900 Subject: [PATCH 023/128] net: fix TestLookupDotsWithLocalSource Fixes #14050. Change-Id: I2d9c32213b0da35703edf28f92ed3efb23325921 Reviewed-on: https://go-review.googlesource.com/18792 Run-TryBot: Mikio Hara Reviewed-by: Ian Lance Taylor TryBot-Result: Gobot Gobot --- src/net/lookup_test.go | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go index 677a5f57fd4..de4c4bd729c 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) From 7d8c8c07aa925a4eb38c3a831dfc4ceeeb40aebf Mon Sep 17 00:00:00 2001 From: Dominik Honnef Date: Sat, 23 Jan 2016 04:57:21 +0100 Subject: [PATCH 024/128] doc: missing words and letters in release notes Change-Id: Ica7f2a000eb1d89d5b02cb8c6f1596ddc04bfb26 Reviewed-on: https://go-review.googlesource.com/18890 Reviewed-by: Ian Lance Taylor --- doc/go1.6.html | 15 ++++++++------- 1 file changed, 8 insertions(+), 7 deletions(-) diff --git a/doc/go1.6.html b/doc/go1.6.html index 61b2449dad0..5e5149fa101 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.

@@ -588,7 +588,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,13 +631,13 @@ 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 @@ -731,10 +731,11 @@ Second, the Expect: 100-continue header (see Transport.ExpectContinueTimeout). Third, there are -four new error codes from RFC 6585: +five new error codes from RFC 6585: StatusPreconditionRequired (428), StatusTooManyRequests (429), StatusRequestHeaderFieldsTooLarge (431), +StatusUnavailableForLegalReasons (451)), and StatusNetworkAuthenticationRequired (511). Fourth, the implementation and documentation of @@ -825,7 +826,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 From e8b53c92b8086af8c5f279c795951a9aa1a14d58 Mon Sep 17 00:00:00 2001 From: Mikio Hara Date: Sat, 23 Jan 2016 13:28:14 +0900 Subject: [PATCH 025/128] net: enable TestLookupDotsWithRemoteSource on builders Change-Id: I2609660b10a16ec2a256fc9c8e046ba4ae67963f Reviewed-on: https://go-review.googlesource.com/18880 Reviewed-by: Ian Lance Taylor --- src/net/lookup_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/net/lookup_test.go b/src/net/lookup_test.go index de4c4bd729c..439496ac81d 100644 --- a/src/net/lookup_test.go +++ b/src/net/lookup_test.go @@ -466,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") } From a5ba581ae05a857a7828c5a883fab0d73a89f26d Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 5 Jan 2016 09:48:45 -0500 Subject: [PATCH 026/128] cmd/asm: simplify golden test maintenance Instead of two parallel files that look almost identical, mark the expected differences in the original file. The annotations being added here keep the tests passing, but they also make clear a number of printing or parsing errors that were not as easily seen when the data was split across two files. Fix a few diagnostic problems in cmd/internal/obj as well. A step toward #13822. Change-Id: I997172681ea6fa7da915ff0f0ab93d2b76f8dce2 Reviewed-on: https://go-review.googlesource.com/18823 Run-TryBot: Russ Cox Reviewed-by: Rob Pike TryBot-Result: Gobot Gobot --- src/cmd/asm/internal/arch/arm.go | 1 + src/cmd/asm/internal/asm/asm.go | 2 +- src/cmd/asm/internal/asm/endtoend_test.go | 122 +++++++++++++++---- src/cmd/asm/internal/asm/testdata/386.out | 49 -------- src/cmd/asm/internal/asm/testdata/386.s | 37 +++--- src/cmd/asm/internal/asm/testdata/amd64.out | 57 --------- src/cmd/asm/internal/asm/testdata/amd64.s | 80 +++++++----- src/cmd/asm/internal/asm/testdata/arm.out | 60 --------- src/cmd/asm/internal/asm/testdata/arm.s | 47 +++---- src/cmd/asm/internal/asm/testdata/arm64.out | 55 --------- src/cmd/asm/internal/asm/testdata/arm64.s | 23 ++-- src/cmd/asm/internal/asm/testdata/mips64.out | 99 --------------- src/cmd/asm/internal/asm/testdata/mips64.s | 41 ++++--- src/cmd/asm/internal/asm/testdata/ppc64.out | 114 ----------------- src/cmd/asm/internal/asm/testdata/ppc64.s | 78 ++++++------ src/cmd/internal/obj/arm/anames5.go | 1 + src/cmd/internal/obj/arm/asm5.go | 8 +- src/cmd/internal/obj/arm64/a.out.go | 7 -- src/cmd/internal/obj/arm64/anames.go | 7 -- 19 files changed, 286 insertions(+), 602 deletions(-) delete mode 100644 src/cmd/asm/internal/asm/testdata/386.out delete mode 100644 src/cmd/asm/internal/asm/testdata/amd64.out delete mode 100644 src/cmd/asm/internal/asm/testdata/arm.out delete mode 100644 src/cmd/asm/internal/asm/testdata/arm64.out delete mode 100644 src/cmd/asm/internal/asm/testdata/mips64.out delete mode 100644 src/cmd/asm/internal/asm/testdata/ppc64.out 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..bba82b5fca0 100644 --- a/src/cmd/asm/internal/asm/endtoend_test.go +++ b/src/cmd/asm/internal/asm/endtoend_test.go @@ -8,9 +8,9 @@ import ( "bytes" "fmt" "io/ioutil" - "log" "os" "path/filepath" + "strconv" "strings" "testing" @@ -25,48 +25,122 @@ import ( func testEndToEnd(t *testing.T, goarch string) { lex.InitHist() input := filepath.Join("testdata", goarch+".s") - output := filepath.Join("testdata", goarch+".out") 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 + ctxt.Diag = t.Errorf obj.Binitw(ioutil.Discard) pList.Firstpc, ok = parser.Parse() - if !ok { + if !ok || t.Failed() { t.Fatalf("asm: %s assembly failed", goarch) } - result := string(testOut.Bytes()) - expect, err := ioutil.ReadFile(output) - // For Windows. - result = strings.Replace(result, `testdata\`, `testdata/`, -1) + output := strings.Split(testOut.String(), "\n") + + // Reconstruct expected output by independently "parsing" the input. + data, err := ioutil.ReadFile(input) if err != nil { t.Fatal(err) } - if result != string(expect) { - if false { // Enable to capture output. - fmt.Printf("%s", result) - os.Exit(1) + lineno := 0 + seq := 0 +Diff: + for _, line := range strings.SplitAfter(string(data), "\n") { + 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)) + seq++ + + switch len(parts) { + default: + t.Errorf("%s:%d: unable to understand comments: %s", input, lineno, line) + case 1: + // no comment + case 2: + // one comment, printed form + printed = strings.TrimSpace(parts[1]) } - n := len(e) - if n > len(r) { - n = len(r) + + // 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) } - 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]) + + 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:] } } 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..35af32a5cd4 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,38 @@ 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 // LTYPE0 nonnon { outcode($1, &$2); } 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.S $0.5, F2 // MOVF.S $(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/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..f78b08445ff 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: 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", From 36edf48a1078f1a39f1299276354ecd3190f6837 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Thu, 21 Jan 2016 22:48:29 -0500 Subject: [PATCH 027/128] cmd/asm: report more than one instruction encoding error Also, remove output file if there are encoding errors. The extra reports are convenient. Removing the output file is very important. Noticed while testing. Change-Id: I0fab17d4078f93c5a0d6d1217d8d9a63ac789696 Reviewed-on: https://go-review.googlesource.com/18845 Reviewed-by: Rob Pike --- src/cmd/asm/main.go | 13 ++++++++++--- src/cmd/internal/obj/x86/asm6.go | 3 ++- 2 files changed, 12 insertions(+), 4 deletions(-) diff --git a/src/cmd/asm/main.go b/src/cmd/asm/main.go index db0e28e2e59..528481c1329 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.Diag = 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/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go index 164dbd60647..d5d52bb0556 100644 --- a/src/cmd/internal/obj/x86/asm6.go +++ b/src/cmd/internal/obj/x86/asm6.go @@ -4274,7 +4274,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 } From d2b0c387b2d48fb61ba2fee75c34ed66289c199f Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Fri, 22 Jan 2016 09:35:05 -0500 Subject: [PATCH 028/128] cmd/asm: add YMM registers Y0 through Y15 Not recognized in any instructions yet, but this lets the assembler parse them at least. For #14068. Change-Id: Id4f7329a969b747a867ce261b20165fab2cdcab8 Reviewed-on: https://go-review.googlesource.com/18846 Reviewed-by: Rob Pike --- src/cmd/internal/obj/x86/a.out.go | 17 +++++++++++++++++ src/cmd/internal/obj/x86/list6.go | 16 ++++++++++++++++ 2 files changed, 33 insertions(+) diff --git a/src/cmd/internal/obj/x86/a.out.go b/src/cmd/internal/obj/x86/a.out.go index b3e2d48d249..b02c7495b8f 100644 --- a/src/cmd/internal/obj/x86/a.out.go +++ b/src/cmd/internal/obj/x86/a.out.go @@ -864,6 +864,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/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", From 02717bdc20f0c4d3472c2cba6fce292c9a5c3777 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Fri, 22 Jan 2016 09:49:48 -0500 Subject: [PATCH 029/128] cmd/asm: add -e flag (no limit on errors) to match compiler Change-Id: I5b749c575e0ec78fb3c50d056899bd1fe5d91853 Reviewed-on: https://go-review.googlesource.com/18847 Reviewed-by: Rob Pike --- src/cmd/asm/internal/asm/parse.go | 3 ++- src/cmd/asm/internal/flags/flags.go | 1 + 2 files changed, 3 insertions(+), 1 deletion(-) 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/flags/flags.go b/src/cmd/asm/internal/flags/flags.go index 89bc6f3a8c2..fd42e8443b5 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 ( From f844b0be18ecab2406b2c1d20abb53e358d5574e Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Fri, 22 Jan 2016 12:18:19 -0500 Subject: [PATCH 030/128] cmd/internal/obj/x86: rename POPCNT to POPCNTQ Ilya added POPCNT in a CL earlier this month but it's really only POPCNTQ. The other forms still need to be added. For #4816. Change-Id: I1186850d32ad6d5777475c7808e6fc9d9133e118 Reviewed-on: https://go-review.googlesource.com/18848 Reviewed-by: Rob Pike --- src/cmd/internal/obj/x86/a.out.go | 4 +++- src/cmd/internal/obj/x86/anames.go | 4 +++- src/cmd/internal/obj/x86/asm6.go | 2 +- 3 files changed, 7 insertions(+), 3 deletions(-) diff --git a/src/cmd/internal/obj/x86/a.out.go b/src/cmd/internal/obj/x86/a.out.go index b02c7495b8f..d2bc73ea8f8 100644 --- a/src/cmd/internal/obj/x86/a.out.go +++ b/src/cmd/internal/obj/x86/a.out.go @@ -181,7 +181,9 @@ const ( APAUSE APOPAL APOPAW - APOPCNT + APOPCNTW + APOPCNTL + APOPCNTQ APOPFL APOPFW APOPL diff --git a/src/cmd/internal/obj/x86/anames.go b/src/cmd/internal/obj/x86/anames.go index 392899cf5f3..15e72020066 100644 --- a/src/cmd/internal/obj/x86/anames.go +++ b/src/cmd/internal/obj/x86/anames.go @@ -149,7 +149,9 @@ var Anames = []string{ "PAUSE", "POPAL", "POPAW", - "POPCNT", + "POPCNTW", + "POPCNTL", + "POPCNTQ", "POPFL", "POPFW", "POPL", diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go index d5d52bb0556..41386ef6e0f 100644 --- a/src/cmd/internal/obj/x86/asm6.go +++ b/src/cmd/internal/obj/x86/asm6.go @@ -1208,7 +1208,7 @@ var optab = {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}}, + {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}}, From d3ff40fb1f4daae5b7ef4c54909a35d57e1ca753 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Fri, 22 Jan 2016 15:50:01 -0500 Subject: [PATCH 031/128] cmd/internal/obj/x86: fix doubled REX byte in POPCNT, others Tests for this and many other instructions are in a separate followup CL. For #14068. Change-Id: I6955315996a34d7fb79369b9d9a0119d11745e85 Reviewed-on: https://go-review.googlesource.com/18849 Reviewed-by: Rob Pike --- src/cmd/internal/obj/x86/asm6.go | 12 ++++-------- 1 file changed, 4 insertions(+), 8 deletions(-) diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go index 41386ef6e0f..f67dfa94495 100644 --- a/src/cmd/internal/obj/x86/asm6.go +++ b/src/cmd/internal/obj/x86/asm6.go @@ -3189,12 +3189,10 @@ 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:] @@ -3206,12 +3204,10 @@ 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 Pfw: /* xmm opcode escape + REX.W */ + ctxt.Rexflag |= Pw ctxt.Andptr[0] = Pf3 ctxt.Andptr = ctxt.Andptr[1:] - - ctxt.Andptr[0] = Pw - ctxt.Andptr = ctxt.Andptr[1:] ctxt.Andptr[0] = Pm ctxt.Andptr = ctxt.Andptr[1:] From 2eb8d94dbd822fab695f2781c8b6d14345be1d07 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Thu, 21 Jan 2016 20:48:21 -0500 Subject: [PATCH 032/128] cmd/asm: add test for verification of instruction encodings Not much testing yet, but the test now exists. Another step toward #13822. Change-Id: Idb2b06bf53a6113c83008150b4c0b631bb195279 Reviewed-on: https://go-review.googlesource.com/18844 Reviewed-by: Rob Pike Run-TryBot: Russ Cox --- src/cmd/asm/internal/asm/endtoend_test.go | 160 ++++++++++++++++++---- src/cmd/asm/internal/asm/testdata/amd64.s | 2 +- src/cmd/asm/internal/asm/testdata/arm.s | 2 +- src/cmd/internal/obj/arm/asm5.go | 2 +- 4 files changed, 139 insertions(+), 27 deletions(-) diff --git a/src/cmd/asm/internal/asm/endtoend_test.go b/src/cmd/asm/internal/asm/endtoend_test.go index bba82b5fca0..620bb974175 100644 --- a/src/cmd/asm/internal/asm/endtoend_test.go +++ b/src/cmd/asm/internal/asm/endtoend_test.go @@ -10,6 +10,7 @@ import ( "io/ioutil" "os" "path/filepath" + "sort" "strconv" "strings" "testing" @@ -22,9 +23,9 @@ 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") + input := filepath.Join("testdata", file+".s") architecture, ctxt := setArch(goarch) lexer := lex.NewLexer(input, ctxt) parser := NewParser(ctxt, architecture, lexer) @@ -33,23 +34,31 @@ func testEndToEnd(t *testing.T, goarch string) { testOut = new(bytes.Buffer) // The assembler writes test output to this buffer. ctxt.Bso = obj.Binitw(os.Stdout) defer ctxt.Bso.Flush() - ctxt.Diag = t.Errorf + failed := false + ctxt.Diag = func(format string, args ...interface{}) { + failed = true + t.Errorf(format, args...) + } obj.Binitw(ioutil.Discard) pList.Firstpc, ok = parser.Parse() - if !ok || t.Failed() { - t.Fatalf("asm: %s assembly failed", goarch) + if !ok || failed { + t.Errorf("asm: %s assembly failed", goarch) + return } 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 } lineno := 0 seq := 0 + hexByLine := map[string]string{} + lines := strings.SplitAfter(string(data), "\n") Diff: - for _, line := range strings.SplitAfter(string(data), "\n") { + for _, line := range lines { lineno++ // The general form of a test input line is: @@ -62,14 +71,31 @@ Diff: } 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: - // one comment, printed form + // 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. @@ -142,28 +168,114 @@ Diff: 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.Diag = 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 TestARMEndToEnd(t *testing.T) { - testEndToEnd(t, "arm") -} - -func TestARM64EndToEnd(t *testing.T) { - testEndToEnd(t, "arm64") -} - -func TestAMD64EndToEnd(t *testing.T) { - testEndToEnd(t, "amd64") +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 Test386EndToEnd(t *testing.T) { - testEndToEnd(t, "386") + 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 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/testdata/amd64.s b/src/cmd/asm/internal/asm/testdata/amd64.s index 35af32a5cd4..5512df00348 100644 --- a/src/cmd/asm/internal/asm/testdata/amd64.s +++ b/src/cmd/asm/internal/asm/testdata/amd64.s @@ -122,4 +122,4 @@ loop: LOOP loop // LOOP // LTYPE0 nonnon { outcode($1, &$2); } - RET + RET // c3 diff --git a/src/cmd/asm/internal/asm/testdata/arm.s b/src/cmd/asm/internal/asm/testdata/arm.s index 0102cd84146..80627502503 100644 --- a/src/cmd/asm/internal/asm/testdata/arm.s +++ b/src/cmd/asm/internal/asm/testdata/arm.s @@ -189,7 +189,7 @@ TEXT foo(SB), 7, $0 // outcode($1, $2, &$3, 0, &$5); // } ADDD.S F1, F2 - MOVF.S $0.5, F2 // MOVF.S $(0.5), F2 + MOVF $0.5, F2 // MOVF $(0.5), F2 // LTYPEK cond frcon ',' LFREG ',' freg // { diff --git a/src/cmd/internal/obj/arm/asm5.go b/src/cmd/internal/obj/arm/asm5.go index f78b08445ff..d75a16354cb 100644 --- a/src/cmd/internal/obj/arm/asm5.go +++ b/src/cmd/internal/obj/arm/asm5.go @@ -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 { From 659c63288567e9808805010fe3e3c2e75b5cd4e3 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Fri, 22 Jan 2016 11:27:49 -0500 Subject: [PATCH 033/128] cmd/asm: add generated test of amd64 instruction encodings Generated by x86test, from https://golang.org/cl/18842 (still in progress). The commented out lines are either missing or misspelled or incorrectly handled instructions. For #4816, #8037, #13822, #14068, #14069. Change-Id: If309310c97d9d2a3c71fc64c51d4a957e9076ab7 Reviewed-on: https://go-review.googlesource.com/18850 Reviewed-by: Rob Pike Run-TryBot: Russ Cox TryBot-Result: Gobot Gobot --- src/cmd/asm/internal/asm/endtoend_test.go | 4 + src/cmd/asm/internal/asm/testdata/amd64enc.s | 10682 +++++++++++++++++ 2 files changed, 10686 insertions(+) create mode 100644 src/cmd/asm/internal/asm/testdata/amd64enc.s diff --git a/src/cmd/asm/internal/asm/endtoend_test.go b/src/cmd/asm/internal/asm/endtoend_test.go index 620bb974175..8f5d56d53a5 100644 --- a/src/cmd/asm/internal/asm/endtoend_test.go +++ b/src/cmd/asm/internal/asm/endtoend_test.go @@ -272,6 +272,10 @@ func TestAMD64EndToEnd(t *testing.T) { testEndToEnd(t, "amd64", "amd64") } +func TestAMD64Encoder(t *testing.T) { + testEndToEnd(t, "amd64", "amd64enc") +} + func TestMIPS64EndToEnd(t *testing.T) { testEndToEnd(t, "mips64", "mips64") } 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..a24e8d3050d --- /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 + //TODO: ANDNL (BX), R9D, DX // c4e230f213 + //TODO: ANDNL (R11), R9D, DX // c4c230f213 + //TODO: ANDNL DX, R9D, DX // c4e230f2d2 + //TODO: ANDNL R11, R9D, DX // c4c230f2d3 + //TODO: ANDNL (BX), R9D, R11 // c46230f21b + //TODO: ANDNL (R11), R9D, R11 // c44230f21b + //TODO: ANDNL DX, R9D, R11 // c46230f2da + //TODO: ANDNL R11, R9D, R11 // c44230f2db + //TODO: ANDNQ (BX), R14, DX // c4e288f213 + //TODO: ANDNQ (R11), R14, DX // c4c288f213 + //TODO: ANDNQ DX, R14, DX // c4e288f2d2 + //TODO: ANDNQ R11, R14, DX // c4c288f2d3 + //TODO: ANDNQ (BX), R14, R11 // c46288f21b + //TODO: ANDNQ (R11), R14, R11 // c44288f21b + //TODO: ANDNQ DX, R14, R11 // c46288f2da + //TODO: 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 + //TODO: BEXTRL R9D, (BX), DX // c4e230f713 + //TODO: BEXTRL R9D, (R11), DX // c4c230f713 + //TODO: BEXTRL R9D, DX, DX // c4e230f7d2 + //TODO: BEXTRL R9D, R11, DX // c4c230f7d3 + //TODO: BEXTRL R9D, (BX), R11 // c46230f71b + //TODO: BEXTRL R9D, (R11), R11 // c44230f71b + //TODO: BEXTRL R9D, DX, R11 // c46230f7da + //TODO: BEXTRL R9D, R11, R11 // c44230f7db + //TODO: BEXTRQ R14, (BX), DX // c4e288f713 + //TODO: BEXTRQ R14, (R11), DX // c4c288f713 + //TODO: BEXTRQ R14, DX, DX // c4e288f7d2 + //TODO: BEXTRQ R14, R11, DX // c4c288f7d3 + //TODO: BEXTRQ R14, (BX), R11 // c46288f71b + //TODO: BEXTRQ R14, (R11), R11 // c44288f71b + //TODO: BEXTRQ R14, DX, R11 // c46288f7da + //TODO: 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), R9D // c4e230f31b + //TODO: BLSIL (R11), R9D // c4c230f31b + //TODO: BLSIL DX, R9D // c4e230f3da + //TODO: BLSIL R11, R9D // c4c230f3db + //TODO: BLSIQ (BX), R14 // c4e288f31b + //TODO: BLSIQ (R11), R14 // c4c288f31b + //TODO: BLSIQ DX, R14 // c4e288f3da + //TODO: BLSIQ R11, R14 // c4c288f3db + //TODO: BLSMSKL (BX), R9D // c4e230f313 + //TODO: BLSMSKL (R11), R9D // c4c230f313 + //TODO: BLSMSKL DX, R9D // c4e230f3d2 + //TODO: BLSMSKL R11, R9D // c4c230f3d3 + //TODO: BLSMSKQ (BX), R14 // c4e288f313 + //TODO: BLSMSKQ (R11), R14 // c4c288f313 + //TODO: BLSMSKQ DX, R14 // c4e288f3d2 + //TODO: BLSMSKQ R11, R14 // c4c288f3d3 + //TODO: BLSRL (BX), R9D // c4e230f30b + //TODO: BLSRL (R11), R9D // c4c230f30b + //TODO: BLSRL DX, R9D // c4e230f3ca + //TODO: BLSRL R11, R9D // 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 + //TODO: BZHIL R9D, (BX), DX // c4e230f513 + //TODO: BZHIL R9D, (R11), DX // c4c230f513 + //TODO: BZHIL R9D, DX, DX // c4e230f5d2 + //TODO: BZHIL R9D, R11, DX // c4c230f5d3 + //TODO: BZHIL R9D, (BX), R11 // c46230f51b + //TODO: BZHIL R9D, (R11), R11 // c44230f51b + //TODO: BZHIL R9D, DX, R11 // c46230f5da + //TODO: BZHIL R9D, R11, R11 // c44230f5db + //TODO: BZHIQ R14, (BX), DX // c4e288f513 + //TODO: BZHIQ R14, (R11), DX // c4c288f513 + //TODO: BZHIQ R14, DX, DX // c4e288f5d2 + //TODO: BZHIQ R14, R11, DX // c4c288f5d3 + //TODO: BZHIQ R14, (BX), R11 // c46288f51b + //TODO: BZHIQ R14, (R11), R11 // c44288f51b + //TODO: BZHIQ R14, DX, R11 // c46288f5da + //TODO: 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 + //TODO: HADDPD (BX), X2 // 660f7c13 + //TODO: HADDPD (R11), X2 // 66410f7c13 + //TODO: HADDPD X2, X2 // 660f7cd2 + //TODO: HADDPD X11, X2 // 66410f7cd3 + //TODO: HADDPD (BX), X11 // 66440f7c1b + //TODO: HADDPD (R11), X11 // 66450f7c1b + //TODO: HADDPD X2, X11 // 66440f7cda + //TODO: HADDPD X11, X11 // 66450f7cdb + //TODO: HADDPS (BX), X2 // f20f7c13 + //TODO: HADDPS (R11), X2 // f2410f7c13 + //TODO: HADDPS X2, X2 // f20f7cd2 + //TODO: HADDPS X11, X2 // f2410f7cd3 + //TODO: HADDPS (BX), X11 // f2440f7c1b + //TODO: HADDPS (R11), X11 // f2450f7c1b + //TODO: HADDPS X2, X11 // f2440f7cda + //TODO: HADDPS X11, X11 // f2450f7cdb + HLT // f4 + //TODO: HSUBPD (BX), X2 // 660f7d13 + //TODO: HSUBPD (R11), X2 // 66410f7d13 + //TODO: HSUBPD X2, X2 // 660f7dd2 + //TODO: HSUBPD X11, X2 // 66410f7dd3 + //TODO: HSUBPD (BX), X11 // 66440f7d1b + //TODO: HSUBPD (R11), X11 // 66450f7d1b + //TODO: HSUBPD X2, X11 // 66440f7dda + //TODO: HSUBPD X11, X11 // 66450f7ddb + //TODO: HSUBPS (BX), X2 // f20f7d13 + //TODO: HSUBPS (R11), X2 // f2410f7d13 + //TODO: HSUBPS X2, X2 // f20f7dd2 + //TODO: HSUBPS X11, X2 // f2410f7dd3 + //TODO: HSUBPS (BX), X11 // f2440f7d1b + //TODO: HSUBPS (R11), X11 // f2450f7d1b + //TODO: HSUBPS X2, X11 // f2440f7dda + //TODO: 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 + //TODO: LDDQU (BX), X2 // f20ff013 + //TODO: LDDQU (R11), X2 // f2410ff013 + //TODO: LDDQU (BX), X11 // f2440ff01b + //TODO: 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 + //TODO: MULXL (BX), R9D, DX // c4e233f613 + //TODO: MULXL (R11), R9D, DX // c4c233f613 + //TODO: MULXL DX, R9D, DX // c4e233f6d2 + //TODO: MULXL R11, R9D, DX // c4c233f6d3 + //TODO: MULXL (BX), R9D, R11 // c46233f61b + //TODO: MULXL (R11), R9D, R11 // c44233f61b + //TODO: MULXL DX, R9D, R11 // c46233f6da + //TODO: MULXL R11, R9D, R11 // c44233f6db + //TODO: MULXQ (BX), R14, DX // c4e28bf613 + //TODO: MULXQ (R11), R14, DX // c4c28bf613 + //TODO: MULXQ DX, R14, DX // c4e28bf6d2 + //TODO: MULXQ R11, R14, DX // c4c28bf6d3 + //TODO: MULXQ (BX), R14, R11 // c4628bf61b + //TODO: MULXQ (R11), R14, R11 // c4428bf61b + //TODO: MULXQ DX, R14, R11 // c4628bf6da + //TODO: 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 + //TODO: PDEPL (BX), R9D, DX // c4e233f513 + //TODO: PDEPL (R11), R9D, DX // c4c233f513 + //TODO: PDEPL DX, R9D, DX // c4e233f5d2 + //TODO: PDEPL R11, R9D, DX // c4c233f5d3 + //TODO: PDEPL (BX), R9D, R11 // c46233f51b + //TODO: PDEPL (R11), R9D, R11 // c44233f51b + //TODO: PDEPL DX, R9D, R11 // c46233f5da + //TODO: PDEPL R11, R9D, R11 // c44233f5db + //TODO: PDEPQ (BX), R14, DX // c4e28bf513 + //TODO: PDEPQ (R11), R14, DX // c4c28bf513 + //TODO: PDEPQ DX, R14, DX // c4e28bf5d2 + //TODO: PDEPQ R11, R14, DX // c4c28bf5d3 + //TODO: PDEPQ (BX), R14, R11 // c4628bf51b + //TODO: PDEPQ (R11), R14, R11 // c4428bf51b + //TODO: PDEPQ DX, R14, R11 // c4628bf5da + //TODO: PDEPQ R11, R14, R11 // c4428bf5db + //TODO: PEXTL (BX), R9D, DX // c4e232f513 + //TODO: PEXTL (R11), R9D, DX // c4c232f513 + //TODO: PEXTL DX, R9D, DX // c4e232f5d2 + //TODO: PEXTL R11, R9D, DX // c4c232f5d3 + //TODO: PEXTL (BX), R9D, R11 // c46232f51b + //TODO: PEXTL (R11), R9D, R11 // c44232f51b + //TODO: PEXTL DX, R9D, R11 // c46232f5da + //TODO: PEXTL R11, R9D, R11 // c44232f5db + //TODO: PEXTQ (BX), R14, DX // c4e28af513 + //TODO: PEXTQ (R11), R14, DX // c4c28af513 + //TODO: PEXTQ DX, R14, DX // c4e28af5d2 + //TODO: PEXTQ R11, R14, DX // c4c28af5d3 + //TODO: PEXTQ (BX), R14, R11 // c4628af51b + //TODO: PEXTQ (R11), R14, R11 // c4428af51b + //TODO: PEXTQ DX, R14, R11 // c4628af5da + //TODO: 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 + //TODO: PHADDD (BX), M2 // 0f380213 + //TODO: PHADDD (R11), M2 // 410f380213 + //TODO: PHADDD M2, M2 // 0f3802d2 + //TODO: PHADDD M3, M2 // 0f3802d3 + //TODO: PHADDD (BX), M3 // 0f38021b + //TODO: PHADDD (R11), M3 // 410f38021b + //TODO: PHADDD M2, M3 // 0f3802da + //TODO: PHADDD M3, M3 // 0f3802db + //TODO: PHADDD (BX), X2 // 660f380213 + //TODO: PHADDD (R11), X2 // 66410f380213 + //TODO: PHADDD X2, X2 // 660f3802d2 + //TODO: PHADDD X11, X2 // 66410f3802d3 + //TODO: PHADDD (BX), X11 // 66440f38021b + //TODO: PHADDD (R11), X11 // 66450f38021b + //TODO: PHADDD X2, X11 // 66440f3802da + //TODO: 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 + //TODO: PMOVSXBD (BX), X2 // 660f382113 + //TODO: PMOVSXBD (R11), X2 // 66410f382113 + //TODO: PMOVSXBD X2, X2 // 660f3821d2 + //TODO: PMOVSXBD X11, X2 // 66410f3821d3 + //TODO: PMOVSXBD (BX), X11 // 66440f38211b + //TODO: PMOVSXBD (R11), X11 // 66450f38211b + //TODO: PMOVSXBD X2, X11 // 66440f3821da + //TODO: PMOVSXBD X11, X11 // 66450f3821db + //TODO: PMOVSXBQ (BX), X2 // 660f382213 + //TODO: PMOVSXBQ (R11), X2 // 66410f382213 + //TODO: PMOVSXBQ X2, X2 // 660f3822d2 + //TODO: PMOVSXBQ X11, X2 // 66410f3822d3 + //TODO: PMOVSXBQ (BX), X11 // 66440f38221b + //TODO: PMOVSXBQ (R11), X11 // 66450f38221b + //TODO: PMOVSXBQ X2, X11 // 66440f3822da + //TODO: PMOVSXBQ X11, X11 // 66450f3822db + //TODO: PMOVSXBW (BX), X2 // 660f382013 + //TODO: PMOVSXBW (R11), X2 // 66410f382013 + //TODO: PMOVSXBW X2, X2 // 660f3820d2 + //TODO: PMOVSXBW X11, X2 // 66410f3820d3 + //TODO: PMOVSXBW (BX), X11 // 66440f38201b + //TODO: PMOVSXBW (R11), X11 // 66450f38201b + //TODO: PMOVSXBW X2, X11 // 66440f3820da + //TODO: PMOVSXBW X11, X11 // 66450f3820db + //TODO: PMOVSXDQ (BX), X2 // 660f382513 + //TODO: PMOVSXDQ (R11), X2 // 66410f382513 + //TODO: PMOVSXDQ X2, X2 // 660f3825d2 + //TODO: PMOVSXDQ X11, X2 // 66410f3825d3 + //TODO: PMOVSXDQ (BX), X11 // 66440f38251b + //TODO: PMOVSXDQ (R11), X11 // 66450f38251b + //TODO: PMOVSXDQ X2, X11 // 66440f3825da + //TODO: PMOVSXDQ X11, X11 // 66450f3825db + //TODO: PMOVSXWD (BX), X2 // 660f382313 + //TODO: PMOVSXWD (R11), X2 // 66410f382313 + //TODO: PMOVSXWD X2, X2 // 660f3823d2 + //TODO: PMOVSXWD X11, X2 // 66410f3823d3 + //TODO: PMOVSXWD (BX), X11 // 66440f38231b + //TODO: PMOVSXWD (R11), X11 // 66450f38231b + //TODO: PMOVSXWD X2, X11 // 66440f3823da + //TODO: PMOVSXWD X11, X11 // 66450f3823db + //TODO: PMOVSXWQ (BX), X2 // 660f382413 + //TODO: PMOVSXWQ (R11), X2 // 66410f382413 + //TODO: PMOVSXWQ X2, X2 // 660f3824d2 + //TODO: PMOVSXWQ X11, X2 // 66410f3824d3 + //TODO: PMOVSXWQ (BX), X11 // 66440f38241b + //TODO: PMOVSXWQ (R11), X11 // 66450f38241b + //TODO: PMOVSXWQ X2, X11 // 66440f3824da + //TODO: PMOVSXWQ X11, X11 // 66450f3824db + //TODO: PMOVZXBD (BX), X2 // 660f383113 + //TODO: PMOVZXBD (R11), X2 // 66410f383113 + //TODO: PMOVZXBD X2, X2 // 660f3831d2 + //TODO: PMOVZXBD X11, X2 // 66410f3831d3 + //TODO: PMOVZXBD (BX), X11 // 66440f38311b + //TODO: PMOVZXBD (R11), X11 // 66450f38311b + //TODO: PMOVZXBD X2, X11 // 66440f3831da + //TODO: PMOVZXBD X11, X11 // 66450f3831db + //TODO: PMOVZXBQ (BX), X2 // 660f383213 + //TODO: PMOVZXBQ (R11), X2 // 66410f383213 + //TODO: PMOVZXBQ X2, X2 // 660f3832d2 + //TODO: PMOVZXBQ X11, X2 // 66410f3832d3 + //TODO: PMOVZXBQ (BX), X11 // 66440f38321b + //TODO: PMOVZXBQ (R11), X11 // 66450f38321b + //TODO: PMOVZXBQ X2, X11 // 66440f3832da + //TODO: PMOVZXBQ X11, X11 // 66450f3832db + //TODO: PMOVZXBW (BX), X2 // 660f383013 + //TODO: PMOVZXBW (R11), X2 // 66410f383013 + //TODO: PMOVZXBW X2, X2 // 660f3830d2 + //TODO: PMOVZXBW X11, X2 // 66410f3830d3 + //TODO: PMOVZXBW (BX), X11 // 66440f38301b + //TODO: PMOVZXBW (R11), X11 // 66450f38301b + //TODO: PMOVZXBW X2, X11 // 66440f3830da + //TODO: PMOVZXBW X11, X11 // 66450f3830db + //TODO: PMOVZXDQ (BX), X2 // 660f383513 + //TODO: PMOVZXDQ (R11), X2 // 66410f383513 + //TODO: PMOVZXDQ X2, X2 // 660f3835d2 + //TODO: PMOVZXDQ X11, X2 // 66410f3835d3 + //TODO: PMOVZXDQ (BX), X11 // 66440f38351b + //TODO: PMOVZXDQ (R11), X11 // 66450f38351b + //TODO: PMOVZXDQ X2, X11 // 66440f3835da + //TODO: PMOVZXDQ X11, X11 // 66450f3835db + //TODO: PMOVZXWD (BX), X2 // 660f383313 + //TODO: PMOVZXWD (R11), X2 // 66410f383313 + //TODO: PMOVZXWD X2, X2 // 660f3833d2 + //TODO: PMOVZXWD X11, X2 // 66410f3833d3 + //TODO: PMOVZXWD (BX), X11 // 66440f38331b + //TODO: PMOVZXWD (R11), X11 // 66450f38331b + //TODO: PMOVZXWD X2, X11 // 66440f3833da + //TODO: PMOVZXWD X11, X11 // 66450f3833db + //TODO: PMOVZXWQ (BX), X2 // 660f383413 + //TODO: PMOVZXWQ (R11), X2 // 66410f383413 + //TODO: PMOVZXWQ X2, X2 // 660f3834d2 + //TODO: PMOVZXWQ X11, X2 // 66410f3834d3 + //TODO: PMOVZXWQ (BX), X11 // 66440f38341b + //TODO: PMOVZXWQ (R11), X11 // 66450f38341b + //TODO: PMOVZXWQ X2, X11 // 66440f3834da + //TODO: PMOVZXWQ X11, X11 // 66450f3834db + //TODO: PMULDQ (BX), X2 // 660f382813 + //TODO: PMULDQ (R11), X2 // 66410f382813 + //TODO: PMULDQ X2, X2 // 660f3828d2 + //TODO: PMULDQ X11, X2 // 66410f3828d3 + //TODO: PMULDQ (BX), X11 // 66440f38281b + //TODO: PMULDQ (R11), X11 // 66450f38281b + //TODO: PMULDQ X2, X11 // 66440f3828da + //TODO: 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 + //TODO: PMULLD (BX), X2 // 660f384013 + //TODO: PMULLD (R11), X2 // 66410f384013 + //TODO: PMULLD X2, X2 // 660f3840d2 + //TODO: PMULLD X11, X2 // 66410f3840d3 + //TODO: PMULLD (BX), X11 // 66440f38401b + //TODO: PMULLD (R11), X11 // 66450f38401b + //TODO: PMULLD X2, X11 // 66440f3840da + //TODO: 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 + //TODO: POPCNTW (BX), DX // 66f30fb813 + //TODO: POPCNTW (R11), DX // 66f3410fb813 + //TODO: POPCNTW DX, DX // 66f30fb8d2 + //TODO: POPCNTW R11, DX // 66f3410fb8d3 + //TODO: POPCNTW (BX), R11 // 66f3440fb81b + //TODO: POPCNTW (R11), R11 // 66f3450fb81b + //TODO: POPCNTW DX, R11 // 66f3440fb8da + //TODO: POPCNTW R11, R11 // 66f3450fb8db + //TODO: POPCNTL (BX), DX // f30fb813 + //TODO: POPCNTL (R11), DX // f3410fb813 + //TODO: POPCNTL DX, DX // f30fb8d2 + //TODO: POPCNTL R11, DX // f3410fb8d3 + //TODO: POPCNTL (BX), R11 // f3440fb81b + //TODO: POPCNTL (R11), R11 // f3450fb81b + //TODO: POPCNTL DX, R11 // f3440fb8da + //TODO: 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 + //TODO: SARXL R9D, (BX), DX // c4e232f713 + //TODO: SARXL R9D, (R11), DX // c4c232f713 + //TODO: SARXL R9D, DX, DX // c4e232f7d2 + //TODO: SARXL R9D, R11, DX // c4c232f7d3 + //TODO: SARXL R9D, (BX), R11 // c46232f71b + //TODO: SARXL R9D, (R11), R11 // c44232f71b + //TODO: SARXL R9D, DX, R11 // c46232f7da + //TODO: SARXL R9D, R11, R11 // c44232f7db + //TODO: SARXQ R14, (BX), DX // c4e28af713 + //TODO: SARXQ R14, (R11), DX // c4c28af713 + //TODO: SARXQ R14, DX, DX // c4e28af7d2 + //TODO: SARXQ R14, R11, DX // c4c28af7d3 + //TODO: SARXQ R14, (BX), R11 // c4628af71b + //TODO: SARXQ R14, (R11), R11 // c4428af71b + //TODO: SARXQ R14, DX, R11 // c4628af7da + //TODO: 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 + //TODO: SHLXL R9D, (BX), DX // c4e231f713 + //TODO: SHLXL R9D, (R11), DX // c4c231f713 + //TODO: SHLXL R9D, DX, DX // c4e231f7d2 + //TODO: SHLXL R9D, R11, DX // c4c231f7d3 + //TODO: SHLXL R9D, (BX), R11 // c46231f71b + //TODO: SHLXL R9D, (R11), R11 // c44231f71b + //TODO: SHLXL R9D, DX, R11 // c46231f7da + //TODO: SHLXL R9D, R11, R11 // c44231f7db + //TODO: SHLXQ R14, (BX), DX // c4e289f713 + //TODO: SHLXQ R14, (R11), DX // c4c289f713 + //TODO: SHLXQ R14, DX, DX // c4e289f7d2 + //TODO: SHLXQ R14, R11, DX // c4c289f7d3 + //TODO: SHLXQ R14, (BX), R11 // c46289f71b + //TODO: SHLXQ R14, (R11), R11 // c44289f71b + //TODO: SHLXQ R14, DX, R11 // c46289f7da + //TODO: 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 + //TODO: SHRXL R9D, (BX), DX // c4e233f713 + //TODO: SHRXL R9D, (R11), DX // c4c233f713 + //TODO: SHRXL R9D, DX, DX // c4e233f7d2 + //TODO: SHRXL R9D, R11, DX // c4c233f7d3 + //TODO: SHRXL R9D, (BX), R11 // c46233f71b + //TODO: SHRXL R9D, (R11), R11 // c44233f71b + //TODO: SHRXL R9D, DX, R11 // c46233f7da + //TODO: SHRXL R9D, R11, R11 // c44233f7db + //TODO: SHRXQ R14, (BX), DX // c4e28bf713 + //TODO: SHRXQ R14, (R11), DX // c4c28bf713 + //TODO: SHRXQ R14, DX, DX // c4e28bf7d2 + //TODO: SHRXQ R14, R11, DX // c4c28bf7d3 + //TODO: SHRXQ R14, (BX), R11 // c4628bf71b + //TODO: SHRXQ R14, (R11), R11 // c4428bf71b + //TODO: SHRXQ R14, DX, R11 // c4628bf7da + //TODO: 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 + //TODO: VMOVDQA (BX), X2 // c4e1796f13 or c5f96f13 + //TODO: VMOVDQA (R11), X2 // c4c1796f13 + //TODO: VMOVDQA X2, X2 // c4e1796fd2 or c5f96fd2 or c4e1797fd2 or c5f97fd2 + //TODO: VMOVDQA X11, X2 // c4c1796fd3 or c461797fda or c5797fda + //TODO: VMOVDQA (BX), X11 // c461796f1b or c5796f1b + //TODO: VMOVDQA (R11), X11 // c441796f1b + //TODO: VMOVDQA X2, X11 // c461796fda or c5796fda or c4c1797fd3 + //TODO: VMOVDQA X11, X11 // c441796fdb or c441797fdb + //TODO: VMOVDQA X2, (BX) // c4e1797f13 or c5f97f13 + //TODO: VMOVDQA X11, (BX) // c461797f1b or c5797f1b + //TODO: VMOVDQA X2, (R11) // c4c1797f13 + //TODO: VMOVDQA X11, (R11) // c441797f1b + //TODO: VMOVDQA (BX), Y2 // c4e17d6f13 or c5fd6f13 + //TODO: VMOVDQA (R11), Y2 // c4c17d6f13 + //TODO: VMOVDQA Y2, Y2 // c4e17d6fd2 or c5fd6fd2 or c4e17d7fd2 or c5fd7fd2 + //TODO: VMOVDQA Y11, Y2 // c4c17d6fd3 or c4617d7fda or c57d7fda + //TODO: VMOVDQA (BX), Y11 // c4617d6f1b or c57d6f1b + //TODO: VMOVDQA (R11), Y11 // c4417d6f1b + //TODO: VMOVDQA Y2, Y11 // c4617d6fda or c57d6fda or c4c17d7fd3 + //TODO: VMOVDQA Y11, Y11 // c4417d6fdb or c4417d7fdb + //TODO: VMOVDQA Y2, (BX) // c4e17d7f13 or c5fd7f13 + //TODO: VMOVDQA Y11, (BX) // c4617d7f1b or c57d7f1b + //TODO: VMOVDQA Y2, (R11) // c4c17d7f13 + //TODO: VMOVDQA Y11, (R11) // c4417d7f1b + //TODO: VMOVDQU (BX), X2 // c4e17a6f13 or c5fa6f13 + //TODO: VMOVDQU (R11), X2 // c4c17a6f13 + //TODO: VMOVDQU X2, X2 // c4e17a6fd2 or c5fa6fd2 or c4e17a7fd2 or c5fa7fd2 + //TODO: VMOVDQU X11, X2 // c4c17a6fd3 or c4617a7fda or c57a7fda + //TODO: VMOVDQU (BX), X11 // c4617a6f1b or c57a6f1b + //TODO: VMOVDQU (R11), X11 // c4417a6f1b + //TODO: VMOVDQU X2, X11 // c4617a6fda or c57a6fda or c4c17a7fd3 + //TODO: VMOVDQU X11, X11 // c4417a6fdb or c4417a7fdb + //TODO: VMOVDQU X2, (BX) // c4e17a7f13 or c5fa7f13 + //TODO: VMOVDQU X11, (BX) // c4617a7f1b or c57a7f1b + //TODO: VMOVDQU X2, (R11) // c4c17a7f13 + //TODO: VMOVDQU X11, (R11) // c4417a7f1b + //TODO: VMOVDQU (BX), Y2 // c4e17e6f13 or c5fe6f13 + //TODO: VMOVDQU (R11), Y2 // c4c17e6f13 + //TODO: VMOVDQU Y2, Y2 // c4e17e6fd2 or c5fe6fd2 or c4e17e7fd2 or c5fe7fd2 + //TODO: VMOVDQU Y11, Y2 // c4c17e6fd3 or c4617e7fda or c57e7fda + //TODO: VMOVDQU (BX), Y11 // c4617e6f1b or c57e6f1b + //TODO: VMOVDQU (R11), Y11 // c4417e6f1b + //TODO: VMOVDQU Y2, Y11 // c4617e6fda or c57e6fda or c4c17e7fd3 + //TODO: VMOVDQU Y11, Y11 // c4417e6fdb or c4417e7fdb + //TODO: VMOVDQU Y2, (BX) // c4e17e7f13 or c5fe7f13 + //TODO: VMOVDQU Y11, (BX) // c4617e7f1b or c57e7f1b + //TODO: VMOVDQU Y2, (R11) // c4c17e7f13 + //TODO: 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 + //TODO: VMOVNTDQ X2, (BX) // c4e179e713 or c5f9e713 + //TODO: VMOVNTDQ X11, (BX) // c46179e71b or c579e71b + //TODO: VMOVNTDQ X2, (R11) // c4c179e713 + //TODO: VMOVNTDQ X11, (R11) // c44179e71b + //TODO: VMOVNTDQ Y2, (BX) // c4e17de713 or c5fde713 + //TODO: VMOVNTDQ Y11, (BX) // c4617de71b or c57de71b + //TODO: VMOVNTDQ Y2, (R11) // c4c17de713 + //TODO: 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 + //TODO: VPAND (BX), X9, X2 // c4e131db13 or c5b1db13 + //TODO: VPAND (R11), X9, X2 // c4c131db13 + //TODO: VPAND X2, X9, X2 // c4e131dbd2 or c5b1dbd2 + //TODO: VPAND X11, X9, X2 // c4c131dbd3 + //TODO: VPAND (BX), X9, X11 // c46131db1b or c531db1b + //TODO: VPAND (R11), X9, X11 // c44131db1b + //TODO: VPAND X2, X9, X11 // c46131dbda or c531dbda + //TODO: VPAND X11, X9, X11 // c44131dbdb + //TODO: VPAND (BX), Y15, Y2 // c4e105db13 or c585db13 + //TODO: VPAND (R11), Y15, Y2 // c4c105db13 + //TODO: VPAND Y2, Y15, Y2 // c4e105dbd2 or c585dbd2 + //TODO: VPAND Y11, Y15, Y2 // c4c105dbd3 + //TODO: VPAND (BX), Y15, Y11 // c46105db1b or c505db1b + //TODO: VPAND (R11), Y15, Y11 // c44105db1b + //TODO: VPAND Y2, Y15, Y11 // c46105dbda or c505dbda + //TODO: 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 + //TODO: VPBROADCASTB (BX), X2 // c4e2797813 + //TODO: VPBROADCASTB (R11), X2 // c4c2797813 + //TODO: VPBROADCASTB X2, X2 // c4e27978d2 + //TODO: VPBROADCASTB X11, X2 // c4c27978d3 + //TODO: VPBROADCASTB (BX), X11 // c46279781b + //TODO: VPBROADCASTB (R11), X11 // c44279781b + //TODO: VPBROADCASTB X2, X11 // c4627978da + //TODO: VPBROADCASTB X11, X11 // c4427978db + //TODO: VPBROADCASTB (BX), Y2 // c4e27d7813 + //TODO: VPBROADCASTB (R11), Y2 // c4c27d7813 + //TODO: VPBROADCASTB X2, Y2 // c4e27d78d2 + //TODO: VPBROADCASTB X11, Y2 // c4c27d78d3 + //TODO: VPBROADCASTB (BX), Y11 // c4627d781b + //TODO: VPBROADCASTB (R11), Y11 // c4427d781b + //TODO: VPBROADCASTB X2, Y11 // c4627d78da + //TODO: 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 + //TODO: VPCMPEQB (BX), X9, X2 // c4e1317413 or c5b17413 + //TODO: VPCMPEQB (R11), X9, X2 // c4c1317413 + //TODO: VPCMPEQB X2, X9, X2 // c4e13174d2 or c5b174d2 + //TODO: VPCMPEQB X11, X9, X2 // c4c13174d3 + //TODO: VPCMPEQB (BX), X9, X11 // c46131741b or c531741b + //TODO: VPCMPEQB (R11), X9, X11 // c44131741b + //TODO: VPCMPEQB X2, X9, X11 // c4613174da or c53174da + //TODO: VPCMPEQB X11, X9, X11 // c4413174db + //TODO: VPCMPEQB (BX), Y15, Y2 // c4e1057413 or c5857413 + //TODO: VPCMPEQB (R11), Y15, Y2 // c4c1057413 + //TODO: VPCMPEQB Y2, Y15, Y2 // c4e10574d2 or c58574d2 + //TODO: VPCMPEQB Y11, Y15, Y2 // c4c10574d3 + //TODO: VPCMPEQB (BX), Y15, Y11 // c46105741b or c505741b + //TODO: VPCMPEQB (R11), Y15, Y11 // c44105741b + //TODO: VPCMPEQB Y2, Y15, Y11 // c4610574da or c50574da + //TODO: 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 + //TODO: VPMOVMSKB X2, DX // c4e179d7d2 or c5f9d7d2 + //TODO: VPMOVMSKB X11, DX // c4c179d7d3 + //TODO: VPMOVMSKB X2, R11 // c46179d7da or c579d7da + //TODO: VPMOVMSKB X11, R11 // c44179d7db + //TODO: VPMOVMSKB Y2, DX // c4e17dd7d2 or c5fdd7d2 + //TODO: VPMOVMSKB Y11, DX // c4c17dd7d3 + //TODO: VPMOVMSKB Y2, R11 // c4617dd7da or c57dd7da + //TODO: 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 + //TODO: VPTEST (BX), X2 // c4e2791713 + //TODO: VPTEST (R11), X2 // c4c2791713 + //TODO: VPTEST X2, X2 // c4e27917d2 + //TODO: VPTEST X11, X2 // c4c27917d3 + //TODO: VPTEST (BX), X11 // c46279171b + //TODO: VPTEST (R11), X11 // c44279171b + //TODO: VPTEST X2, X11 // c4627917da + //TODO: VPTEST X11, X11 // c4427917db + //TODO: VPTEST (BX), Y2 // c4e27d1713 + //TODO: VPTEST (R11), Y2 // c4c27d1713 + //TODO: VPTEST Y2, Y2 // c4e27d17d2 + //TODO: VPTEST Y11, Y2 // c4c27d17d3 + //TODO: VPTEST (BX), Y11 // c4627d171b + //TODO: VPTEST (R11), Y11 // c4427d171b + //TODO: VPTEST Y2, Y11 // c4627d17da + //TODO: 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 + //TODO: VPXOR (BX), X9, X2 // c4e131ef13 or c5b1ef13 + //TODO: VPXOR (R11), X9, X2 // c4c131ef13 + //TODO: VPXOR X2, X9, X2 // c4e131efd2 or c5b1efd2 + //TODO: VPXOR X11, X9, X2 // c4c131efd3 + //TODO: VPXOR (BX), X9, X11 // c46131ef1b or c531ef1b + //TODO: VPXOR (R11), X9, X11 // c44131ef1b + //TODO: VPXOR X2, X9, X11 // c46131efda or c531efda + //TODO: VPXOR X11, X9, X11 // c44131efdb + //TODO: VPXOR (BX), Y15, Y2 // c4e105ef13 or c585ef13 + //TODO: VPXOR (R11), Y15, Y2 // c4c105ef13 + //TODO: VPXOR Y2, Y15, Y2 // c4e105efd2 or c585efd2 + //TODO: VPXOR Y11, Y15, Y2 // c4c105efd3 + //TODO: VPXOR (BX), Y15, Y11 // c46105ef1b or c505ef1b + //TODO: VPXOR (R11), Y15, Y11 // c44105ef1b + //TODO: VPXOR Y2, Y15, Y11 // c46105efda or c505efda + //TODO: 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 From 7f620a57d01ec4230a69c4ee96d3809cfd6febab Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Fri, 22 Jan 2016 16:25:06 -0500 Subject: [PATCH 034/128] cmd/asm: add x86 POPCNTW, POPCNTL Fixes #4816. Change-Id: Ibeaa69f57b7519d56df4ea357edf8d9dc2102ffe Reviewed-on: https://go-review.googlesource.com/18851 Reviewed-by: Rob Pike Run-TryBot: Russ Cox TryBot-Result: Gobot Gobot --- src/cmd/asm/internal/asm/testdata/amd64enc.s | 32 ++++++++++---------- src/cmd/internal/obj/x86/asm6.go | 11 +++++++ 2 files changed, 27 insertions(+), 16 deletions(-) diff --git a/src/cmd/asm/internal/asm/testdata/amd64enc.s b/src/cmd/asm/internal/asm/testdata/amd64enc.s index a24e8d3050d..ae743afe448 100644 --- a/src/cmd/asm/internal/asm/testdata/amd64enc.s +++ b/src/cmd/asm/internal/asm/testdata/amd64enc.s @@ -4145,22 +4145,22 @@ TEXT asmtest(SB),7,$0 POPQ DX // 8fc2 or 5a PUSHQ AX POPQ R11 // 418fc3 or 415b - //TODO: POPCNTW (BX), DX // 66f30fb813 - //TODO: POPCNTW (R11), DX // 66f3410fb813 - //TODO: POPCNTW DX, DX // 66f30fb8d2 - //TODO: POPCNTW R11, DX // 66f3410fb8d3 - //TODO: POPCNTW (BX), R11 // 66f3440fb81b - //TODO: POPCNTW (R11), R11 // 66f3450fb81b - //TODO: POPCNTW DX, R11 // 66f3440fb8da - //TODO: POPCNTW R11, R11 // 66f3450fb8db - //TODO: POPCNTL (BX), DX // f30fb813 - //TODO: POPCNTL (R11), DX // f3410fb813 - //TODO: POPCNTL DX, DX // f30fb8d2 - //TODO: POPCNTL R11, DX // f3410fb8d3 - //TODO: POPCNTL (BX), R11 // f3440fb81b - //TODO: POPCNTL (R11), R11 // f3450fb81b - //TODO: POPCNTL DX, R11 // f3440fb8da - //TODO: POPCNTL R11, R11 // f3450fb8db + 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 diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go index f67dfa94495..2ffceceba94 100644 --- a/src/cmd/internal/obj/x86/asm6.go +++ b/src/cmd/internal/obj/x86/asm6.go @@ -219,6 +219,7 @@ const ( 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 */ Pfw = 0xf4 /* Pf3 with Rex.w: f3 48 0f */ Pvex1 = 0xc5 /* 66.0f escape, vex encoding */ @@ -1208,6 +1209,8 @@ var optab = {APMULULQ, ymm, Py1, [23]uint8{0xf4, Pe, 0xf4}}, {APOPAL, ynone, P32, [23]uint8{0x61}}, {APOPAW, ynone, Pe, [23]uint8{0x61}}, + {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}}, @@ -3204,6 +3207,14 @@ func doasm(ctxt *obj.Link, p *obj.Prog) { ctxt.Andptr[0] = Pm ctxt.Andptr = ctxt.Andptr[1:] + 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:] + case Pfw: /* xmm opcode escape + REX.W */ ctxt.Rexflag |= Pw ctxt.Andptr[0] = Pf3 From 8d881b811d8212ffd1d43e296f2a1c1bf78198ab Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Fri, 22 Jan 2016 22:25:15 -0500 Subject: [PATCH 035/128] cmd/asm: correct, complete newly added AVX instructions Use the standard names, for discoverability. Use the standard register arguments, for correctness. Implement all possible arguments, for completeness. Enable the corresponding tests now that everything is standard. Update the uses in package runtime. Fixes #14068. Change-Id: I8e1af9a41e7d02d98c2a82af3d4cdb3e9204824f Reviewed-on: https://go-review.googlesource.com/18852 Run-TryBot: Russ Cox TryBot-Result: Gobot Gobot Reviewed-by: Rob Pike --- src/cmd/asm/internal/asm/testdata/amd64enc.s | 288 +++++++-------- src/cmd/internal/obj/x86/a.out.go | 7 +- src/cmd/internal/obj/x86/anames.go | 7 +- src/cmd/internal/obj/x86/asm6.go | 366 +++++++++++-------- src/runtime/asm_amd64.s | 48 +-- src/runtime/memclr_amd64.s | 36 +- 6 files changed, 417 insertions(+), 335 deletions(-) diff --git a/src/cmd/asm/internal/asm/testdata/amd64enc.s b/src/cmd/asm/internal/asm/testdata/amd64enc.s index ae743afe448..36b3101232d 100644 --- a/src/cmd/asm/internal/asm/testdata/amd64enc.s +++ b/src/cmd/asm/internal/asm/testdata/amd64enc.s @@ -7658,54 +7658,54 @@ TEXT asmtest(SB),7,$0 //TODO: VMOVDDUP (R11), Y11 // c4417f121b //TODO: VMOVDDUP Y2, Y11 // c4617f12da or c57f12da //TODO: VMOVDDUP Y11, Y11 // c4417f12db - //TODO: VMOVDQA (BX), X2 // c4e1796f13 or c5f96f13 - //TODO: VMOVDQA (R11), X2 // c4c1796f13 - //TODO: VMOVDQA X2, X2 // c4e1796fd2 or c5f96fd2 or c4e1797fd2 or c5f97fd2 - //TODO: VMOVDQA X11, X2 // c4c1796fd3 or c461797fda or c5797fda - //TODO: VMOVDQA (BX), X11 // c461796f1b or c5796f1b - //TODO: VMOVDQA (R11), X11 // c441796f1b - //TODO: VMOVDQA X2, X11 // c461796fda or c5796fda or c4c1797fd3 - //TODO: VMOVDQA X11, X11 // c441796fdb or c441797fdb - //TODO: VMOVDQA X2, (BX) // c4e1797f13 or c5f97f13 - //TODO: VMOVDQA X11, (BX) // c461797f1b or c5797f1b - //TODO: VMOVDQA X2, (R11) // c4c1797f13 - //TODO: VMOVDQA X11, (R11) // c441797f1b - //TODO: VMOVDQA (BX), Y2 // c4e17d6f13 or c5fd6f13 - //TODO: VMOVDQA (R11), Y2 // c4c17d6f13 - //TODO: VMOVDQA Y2, Y2 // c4e17d6fd2 or c5fd6fd2 or c4e17d7fd2 or c5fd7fd2 - //TODO: VMOVDQA Y11, Y2 // c4c17d6fd3 or c4617d7fda or c57d7fda - //TODO: VMOVDQA (BX), Y11 // c4617d6f1b or c57d6f1b - //TODO: VMOVDQA (R11), Y11 // c4417d6f1b - //TODO: VMOVDQA Y2, Y11 // c4617d6fda or c57d6fda or c4c17d7fd3 - //TODO: VMOVDQA Y11, Y11 // c4417d6fdb or c4417d7fdb - //TODO: VMOVDQA Y2, (BX) // c4e17d7f13 or c5fd7f13 - //TODO: VMOVDQA Y11, (BX) // c4617d7f1b or c57d7f1b - //TODO: VMOVDQA Y2, (R11) // c4c17d7f13 - //TODO: VMOVDQA Y11, (R11) // c4417d7f1b - //TODO: VMOVDQU (BX), X2 // c4e17a6f13 or c5fa6f13 - //TODO: VMOVDQU (R11), X2 // c4c17a6f13 - //TODO: VMOVDQU X2, X2 // c4e17a6fd2 or c5fa6fd2 or c4e17a7fd2 or c5fa7fd2 - //TODO: VMOVDQU X11, X2 // c4c17a6fd3 or c4617a7fda or c57a7fda - //TODO: VMOVDQU (BX), X11 // c4617a6f1b or c57a6f1b - //TODO: VMOVDQU (R11), X11 // c4417a6f1b - //TODO: VMOVDQU X2, X11 // c4617a6fda or c57a6fda or c4c17a7fd3 - //TODO: VMOVDQU X11, X11 // c4417a6fdb or c4417a7fdb - //TODO: VMOVDQU X2, (BX) // c4e17a7f13 or c5fa7f13 - //TODO: VMOVDQU X11, (BX) // c4617a7f1b or c57a7f1b - //TODO: VMOVDQU X2, (R11) // c4c17a7f13 - //TODO: VMOVDQU X11, (R11) // c4417a7f1b - //TODO: VMOVDQU (BX), Y2 // c4e17e6f13 or c5fe6f13 - //TODO: VMOVDQU (R11), Y2 // c4c17e6f13 - //TODO: VMOVDQU Y2, Y2 // c4e17e6fd2 or c5fe6fd2 or c4e17e7fd2 or c5fe7fd2 - //TODO: VMOVDQU Y11, Y2 // c4c17e6fd3 or c4617e7fda or c57e7fda - //TODO: VMOVDQU (BX), Y11 // c4617e6f1b or c57e6f1b - //TODO: VMOVDQU (R11), Y11 // c4417e6f1b - //TODO: VMOVDQU Y2, Y11 // c4617e6fda or c57e6fda or c4c17e7fd3 - //TODO: VMOVDQU Y11, Y11 // c4417e6fdb or c4417e7fdb - //TODO: VMOVDQU Y2, (BX) // c4e17e7f13 or c5fe7f13 - //TODO: VMOVDQU Y11, (BX) // c4617e7f1b or c57e7f1b - //TODO: VMOVDQU Y2, (R11) // c4c17e7f13 - //TODO: VMOVDQU Y11, (R11) // c4417e7f1b + 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 @@ -7762,14 +7762,14 @@ TEXT asmtest(SB),7,$0 //TODO: VMOVMSKPS Y11, DX // c4c17c50d3 //TODO: VMOVMSKPS Y2, R11 // c4617c50da or c57c50da //TODO: VMOVMSKPS Y11, R11 // c4417c50db - //TODO: VMOVNTDQ X2, (BX) // c4e179e713 or c5f9e713 - //TODO: VMOVNTDQ X11, (BX) // c46179e71b or c579e71b - //TODO: VMOVNTDQ X2, (R11) // c4c179e713 - //TODO: VMOVNTDQ X11, (R11) // c44179e71b - //TODO: VMOVNTDQ Y2, (BX) // c4e17de713 or c5fde713 - //TODO: VMOVNTDQ Y11, (BX) // c4617de71b or c57de71b - //TODO: VMOVNTDQ Y2, (R11) // c4c17de713 - //TODO: VMOVNTDQ Y11, (R11) // c4417de71b + 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 @@ -8270,22 +8270,22 @@ TEXT asmtest(SB),7,$0 //TODO: VPALIGNR $7, (R11), Y15, Y11 // c443050f1b07 //TODO: VPALIGNR $7, Y2, Y15, Y11 // c463050fda07 //TODO: VPALIGNR $7, Y11, Y15, Y11 // c443050fdb07 - //TODO: VPAND (BX), X9, X2 // c4e131db13 or c5b1db13 - //TODO: VPAND (R11), X9, X2 // c4c131db13 - //TODO: VPAND X2, X9, X2 // c4e131dbd2 or c5b1dbd2 - //TODO: VPAND X11, X9, X2 // c4c131dbd3 - //TODO: VPAND (BX), X9, X11 // c46131db1b or c531db1b - //TODO: VPAND (R11), X9, X11 // c44131db1b - //TODO: VPAND X2, X9, X11 // c46131dbda or c531dbda - //TODO: VPAND X11, X9, X11 // c44131dbdb - //TODO: VPAND (BX), Y15, Y2 // c4e105db13 or c585db13 - //TODO: VPAND (R11), Y15, Y2 // c4c105db13 - //TODO: VPAND Y2, Y15, Y2 // c4e105dbd2 or c585dbd2 - //TODO: VPAND Y11, Y15, Y2 // c4c105dbd3 - //TODO: VPAND (BX), Y15, Y11 // c46105db1b or c505db1b - //TODO: VPAND (R11), Y15, Y11 // c44105db1b - //TODO: VPAND Y2, Y15, Y11 // c46105dbda or c505dbda - //TODO: VPAND Y11, Y15, Y11 // c44105dbdb + 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 @@ -8382,22 +8382,22 @@ TEXT asmtest(SB),7,$0 //TODO: VPBLENDW $7, (R11), Y15, Y11 // c443050e1b07 //TODO: VPBLENDW $7, Y2, Y15, Y11 // c463050eda07 //TODO: VPBLENDW $7, Y11, Y15, Y11 // c443050edb07 - //TODO: VPBROADCASTB (BX), X2 // c4e2797813 - //TODO: VPBROADCASTB (R11), X2 // c4c2797813 - //TODO: VPBROADCASTB X2, X2 // c4e27978d2 - //TODO: VPBROADCASTB X11, X2 // c4c27978d3 - //TODO: VPBROADCASTB (BX), X11 // c46279781b - //TODO: VPBROADCASTB (R11), X11 // c44279781b - //TODO: VPBROADCASTB X2, X11 // c4627978da - //TODO: VPBROADCASTB X11, X11 // c4427978db - //TODO: VPBROADCASTB (BX), Y2 // c4e27d7813 - //TODO: VPBROADCASTB (R11), Y2 // c4c27d7813 - //TODO: VPBROADCASTB X2, Y2 // c4e27d78d2 - //TODO: VPBROADCASTB X11, Y2 // c4c27d78d3 - //TODO: VPBROADCASTB (BX), Y11 // c4627d781b - //TODO: VPBROADCASTB (R11), Y11 // c4427d781b - //TODO: VPBROADCASTB X2, Y11 // c4627d78da - //TODO: VPBROADCASTB X11, Y11 // c4427d78db + 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 @@ -8454,22 +8454,22 @@ TEXT asmtest(SB),7,$0 //TODO: VPCLMULQDQ $7, (R11), X9, X11 // c44331441b07 //TODO: VPCLMULQDQ $7, X2, X9, X11 // c4633144da07 //TODO: VPCLMULQDQ $7, X11, X9, X11 // c4433144db07 - //TODO: VPCMPEQB (BX), X9, X2 // c4e1317413 or c5b17413 - //TODO: VPCMPEQB (R11), X9, X2 // c4c1317413 - //TODO: VPCMPEQB X2, X9, X2 // c4e13174d2 or c5b174d2 - //TODO: VPCMPEQB X11, X9, X2 // c4c13174d3 - //TODO: VPCMPEQB (BX), X9, X11 // c46131741b or c531741b - //TODO: VPCMPEQB (R11), X9, X11 // c44131741b - //TODO: VPCMPEQB X2, X9, X11 // c4613174da or c53174da - //TODO: VPCMPEQB X11, X9, X11 // c4413174db - //TODO: VPCMPEQB (BX), Y15, Y2 // c4e1057413 or c5857413 - //TODO: VPCMPEQB (R11), Y15, Y2 // c4c1057413 - //TODO: VPCMPEQB Y2, Y15, Y2 // c4e10574d2 or c58574d2 - //TODO: VPCMPEQB Y11, Y15, Y2 // c4c10574d3 - //TODO: VPCMPEQB (BX), Y15, Y11 // c46105741b or c505741b - //TODO: VPCMPEQB (R11), Y15, Y11 // c44105741b - //TODO: VPCMPEQB Y2, Y15, Y11 // c4610574da or c50574da - //TODO: VPCMPEQB Y11, Y15, Y11 // c4410574db + 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 @@ -9150,14 +9150,14 @@ TEXT asmtest(SB),7,$0 //TODO: VPMINUW (R11), Y15, Y11 // c442053a1b //TODO: VPMINUW Y2, Y15, Y11 // c462053ada //TODO: VPMINUW Y11, Y15, Y11 // c442053adb - //TODO: VPMOVMSKB X2, DX // c4e179d7d2 or c5f9d7d2 - //TODO: VPMOVMSKB X11, DX // c4c179d7d3 - //TODO: VPMOVMSKB X2, R11 // c46179d7da or c579d7da - //TODO: VPMOVMSKB X11, R11 // c44179d7db - //TODO: VPMOVMSKB Y2, DX // c4e17dd7d2 or c5fdd7d2 - //TODO: VPMOVMSKB Y11, DX // c4c17dd7d3 - //TODO: VPMOVMSKB Y2, R11 // c4617dd7da or c57dd7da - //TODO: VPMOVMSKB Y11, R11 // c4417dd7db + 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 @@ -9942,22 +9942,22 @@ TEXT asmtest(SB),7,$0 //TODO: VPSUBW (R11), Y15, Y11 // c44105f91b //TODO: VPSUBW Y2, Y15, Y11 // c46105f9da or c505f9da //TODO: VPSUBW Y11, Y15, Y11 // c44105f9db - //TODO: VPTEST (BX), X2 // c4e2791713 - //TODO: VPTEST (R11), X2 // c4c2791713 - //TODO: VPTEST X2, X2 // c4e27917d2 - //TODO: VPTEST X11, X2 // c4c27917d3 - //TODO: VPTEST (BX), X11 // c46279171b - //TODO: VPTEST (R11), X11 // c44279171b - //TODO: VPTEST X2, X11 // c4627917da - //TODO: VPTEST X11, X11 // c4427917db - //TODO: VPTEST (BX), Y2 // c4e27d1713 - //TODO: VPTEST (R11), Y2 // c4c27d1713 - //TODO: VPTEST Y2, Y2 // c4e27d17d2 - //TODO: VPTEST Y11, Y2 // c4c27d17d3 - //TODO: VPTEST (BX), Y11 // c4627d171b - //TODO: VPTEST (R11), Y11 // c4427d171b - //TODO: VPTEST Y2, Y11 // c4627d17da - //TODO: VPTEST Y11, Y11 // c4427d17db + 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 @@ -10086,22 +10086,22 @@ TEXT asmtest(SB),7,$0 //TODO: VPUNPCKLWD (R11), Y15, Y11 // c44105611b //TODO: VPUNPCKLWD Y2, Y15, Y11 // c4610561da or c50561da //TODO: VPUNPCKLWD Y11, Y15, Y11 // c4410561db - //TODO: VPXOR (BX), X9, X2 // c4e131ef13 or c5b1ef13 - //TODO: VPXOR (R11), X9, X2 // c4c131ef13 - //TODO: VPXOR X2, X9, X2 // c4e131efd2 or c5b1efd2 - //TODO: VPXOR X11, X9, X2 // c4c131efd3 - //TODO: VPXOR (BX), X9, X11 // c46131ef1b or c531ef1b - //TODO: VPXOR (R11), X9, X11 // c44131ef1b - //TODO: VPXOR X2, X9, X11 // c46131efda or c531efda - //TODO: VPXOR X11, X9, X11 // c44131efdb - //TODO: VPXOR (BX), Y15, Y2 // c4e105ef13 or c585ef13 - //TODO: VPXOR (R11), Y15, Y2 // c4c105ef13 - //TODO: VPXOR Y2, Y15, Y2 // c4e105efd2 or c585efd2 - //TODO: VPXOR Y11, Y15, Y2 // c4c105efd3 - //TODO: VPXOR (BX), Y15, Y11 // c46105ef1b or c505ef1b - //TODO: VPXOR (R11), Y15, Y11 // c44105ef1b - //TODO: VPXOR Y2, Y15, Y11 // c46105efda or c505efda - //TODO: VPXOR Y11, Y15, Y11 // c44105efdb + 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 diff --git a/src/cmd/internal/obj/x86/a.out.go b/src/cmd/internal/obj/x86/a.out.go index d2bc73ea8f8..6c7eaa12e67 100644 --- a/src/cmd/internal/obj/x86/a.out.go +++ b/src/cmd/internal/obj/x86/a.out.go @@ -551,6 +551,7 @@ const ( AFXRSTOR64 AFXSAVE AFXSAVE64 + ALDDQU ALDMXCSR AMASKMOVOU AMASKMOVQ @@ -751,9 +752,9 @@ const ( APCLMULQDQ AVZEROUPPER - AMOVHDU - AMOVNTHD - AMOVHDA + AVMOVDQU + AVMOVNTDQ + AVMOVDQA AVPCMPEQB AVPXOR AVPMOVMSKB diff --git a/src/cmd/internal/obj/x86/anames.go b/src/cmd/internal/obj/x86/anames.go index 15e72020066..70ac5d97637 100644 --- a/src/cmd/internal/obj/x86/anames.go +++ b/src/cmd/internal/obj/x86/anames.go @@ -500,6 +500,7 @@ var Anames = []string{ "FXRSTOR64", "FXSAVE", "FXSAVE64", + "LDDQU", "LDMXCSR", "MASKMOVOU", "MASKMOVQ", @@ -692,9 +693,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 2ffceceba94..c19c03826c1 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,30 +205,30 @@ const ( Zil_rr Zclr Zbyte + Zvex_rm_v_r + Zvex_r_v_rm 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 */ - Pef3 = 0xf5 /* xmm escape 2 with 16-bit prefix: 66 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 */ + 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 */ @@ -237,6 +236,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 @@ -631,20 +699,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}, } @@ -661,11 +715,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}, @@ -744,10 +793,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}, } @@ -772,6 +817,62 @@ var yxabort = []ytab{ {Yu8, Ynone, Ynone, Zib_, 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_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}, +} + /* * 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 @@ -1531,16 +1632,18 @@ 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}}, + {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}}, @@ -1931,6 +2034,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 { @@ -1965,6 +2071,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 @@ -2297,6 +2409,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 +2727,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 +3155,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) { @@ -3344,13 +3437,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) @@ -3410,20 +3496,14 @@ 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_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) 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/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 From 863d9b66f812844e4bf6d3abc3a8161b25bd242c Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Sat, 23 Jan 2016 22:50:58 -0500 Subject: [PATCH 036/128] cmd/asm: add requested amd64 instructions Add amd64 instructions I promised to add for Go 1.6 at the beginning of January. These may be the last instructions added by hand. I intend to generate the whole set mechanically for Go 1.7. Fixes #13822. Change-Id: I8c6bae2efd25f717f9ec750402e50f408a911d2b Reviewed-on: https://go-review.googlesource.com/18853 Reviewed-by: Rob Pike --- src/cmd/asm/internal/arch/arch.go | 2 +- src/cmd/asm/internal/asm/testdata/amd64.s | 6 + src/cmd/asm/internal/asm/testdata/amd64enc.s | 264 +++++++++---------- src/cmd/internal/obj/x86/a.out.go | 37 ++- src/cmd/internal/obj/x86/anames.go | 37 ++- src/cmd/internal/obj/x86/asm6.go | 42 +++ 6 files changed, 239 insertions(+), 149 deletions(-) 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/asm/testdata/amd64.s b/src/cmd/asm/internal/asm/testdata/amd64.s index 5512df00348..70e76363a4e 100644 --- a/src/cmd/asm/internal/asm/testdata/amd64.s +++ b/src/cmd/asm/internal/asm/testdata/amd64.s @@ -121,5 +121,11 @@ label: 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 + // LTYPE0 nonnon { outcode($1, &$2); } RET // c3 diff --git a/src/cmd/asm/internal/asm/testdata/amd64enc.s b/src/cmd/asm/internal/asm/testdata/amd64enc.s index 36b3101232d..5c44d50fade 100644 --- a/src/cmd/asm/internal/asm/testdata/amd64enc.s +++ b/src/cmd/asm/internal/asm/testdata/amd64enc.s @@ -2148,10 +2148,10 @@ TEXT asmtest(SB),7,$0 //TODO: LARQ (R11), R11 // 4d0f021b //TODO: LARQ DX, R11 // 4c0f02da //TODO: LARQ R11, R11 // 4d0f02db - //TODO: LDDQU (BX), X2 // f20ff013 - //TODO: LDDQU (R11), X2 // f2410ff013 - //TODO: LDDQU (BX), X11 // f2440ff01b - //TODO: LDDQU (R11), X11 // f2450ff01b + 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 @@ -3621,22 +3621,22 @@ TEXT asmtest(SB),7,$0 //TODO: PEXTRW $7, X11, (BX) // 66440f3a151b07 //TODO: PEXTRW $7, X2, (R11) // 66410f3a151307 //TODO: PEXTRW $7, X11, (R11) // 66450f3a151b07 - //TODO: PHADDD (BX), M2 // 0f380213 - //TODO: PHADDD (R11), M2 // 410f380213 - //TODO: PHADDD M2, M2 // 0f3802d2 - //TODO: PHADDD M3, M2 // 0f3802d3 - //TODO: PHADDD (BX), M3 // 0f38021b - //TODO: PHADDD (R11), M3 // 410f38021b - //TODO: PHADDD M2, M3 // 0f3802da - //TODO: PHADDD M3, M3 // 0f3802db - //TODO: PHADDD (BX), X2 // 660f380213 - //TODO: PHADDD (R11), X2 // 66410f380213 - //TODO: PHADDD X2, X2 // 660f3802d2 - //TODO: PHADDD X11, X2 // 66410f3802d3 - //TODO: PHADDD (BX), X11 // 66440f38021b - //TODO: PHADDD (R11), X11 // 66450f38021b - //TODO: PHADDD X2, X11 // 66440f3802da - //TODO: PHADDD X11, X11 // 66450f3802db + 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 @@ -3933,110 +3933,110 @@ TEXT asmtest(SB),7,$0 PMOVMSKB X11, DX // 66410fd7d3 PMOVMSKB X2, R11 // 66440fd7da PMOVMSKB X11, R11 // 66450fd7db - //TODO: PMOVSXBD (BX), X2 // 660f382113 - //TODO: PMOVSXBD (R11), X2 // 66410f382113 - //TODO: PMOVSXBD X2, X2 // 660f3821d2 - //TODO: PMOVSXBD X11, X2 // 66410f3821d3 - //TODO: PMOVSXBD (BX), X11 // 66440f38211b - //TODO: PMOVSXBD (R11), X11 // 66450f38211b - //TODO: PMOVSXBD X2, X11 // 66440f3821da - //TODO: PMOVSXBD X11, X11 // 66450f3821db - //TODO: PMOVSXBQ (BX), X2 // 660f382213 - //TODO: PMOVSXBQ (R11), X2 // 66410f382213 - //TODO: PMOVSXBQ X2, X2 // 660f3822d2 - //TODO: PMOVSXBQ X11, X2 // 66410f3822d3 - //TODO: PMOVSXBQ (BX), X11 // 66440f38221b - //TODO: PMOVSXBQ (R11), X11 // 66450f38221b - //TODO: PMOVSXBQ X2, X11 // 66440f3822da - //TODO: PMOVSXBQ X11, X11 // 66450f3822db - //TODO: PMOVSXBW (BX), X2 // 660f382013 - //TODO: PMOVSXBW (R11), X2 // 66410f382013 - //TODO: PMOVSXBW X2, X2 // 660f3820d2 - //TODO: PMOVSXBW X11, X2 // 66410f3820d3 - //TODO: PMOVSXBW (BX), X11 // 66440f38201b - //TODO: PMOVSXBW (R11), X11 // 66450f38201b - //TODO: PMOVSXBW X2, X11 // 66440f3820da - //TODO: PMOVSXBW X11, X11 // 66450f3820db - //TODO: PMOVSXDQ (BX), X2 // 660f382513 - //TODO: PMOVSXDQ (R11), X2 // 66410f382513 - //TODO: PMOVSXDQ X2, X2 // 660f3825d2 - //TODO: PMOVSXDQ X11, X2 // 66410f3825d3 - //TODO: PMOVSXDQ (BX), X11 // 66440f38251b - //TODO: PMOVSXDQ (R11), X11 // 66450f38251b - //TODO: PMOVSXDQ X2, X11 // 66440f3825da - //TODO: PMOVSXDQ X11, X11 // 66450f3825db - //TODO: PMOVSXWD (BX), X2 // 660f382313 - //TODO: PMOVSXWD (R11), X2 // 66410f382313 - //TODO: PMOVSXWD X2, X2 // 660f3823d2 - //TODO: PMOVSXWD X11, X2 // 66410f3823d3 - //TODO: PMOVSXWD (BX), X11 // 66440f38231b - //TODO: PMOVSXWD (R11), X11 // 66450f38231b - //TODO: PMOVSXWD X2, X11 // 66440f3823da - //TODO: PMOVSXWD X11, X11 // 66450f3823db - //TODO: PMOVSXWQ (BX), X2 // 660f382413 - //TODO: PMOVSXWQ (R11), X2 // 66410f382413 - //TODO: PMOVSXWQ X2, X2 // 660f3824d2 - //TODO: PMOVSXWQ X11, X2 // 66410f3824d3 - //TODO: PMOVSXWQ (BX), X11 // 66440f38241b - //TODO: PMOVSXWQ (R11), X11 // 66450f38241b - //TODO: PMOVSXWQ X2, X11 // 66440f3824da - //TODO: PMOVSXWQ X11, X11 // 66450f3824db - //TODO: PMOVZXBD (BX), X2 // 660f383113 - //TODO: PMOVZXBD (R11), X2 // 66410f383113 - //TODO: PMOVZXBD X2, X2 // 660f3831d2 - //TODO: PMOVZXBD X11, X2 // 66410f3831d3 - //TODO: PMOVZXBD (BX), X11 // 66440f38311b - //TODO: PMOVZXBD (R11), X11 // 66450f38311b - //TODO: PMOVZXBD X2, X11 // 66440f3831da - //TODO: PMOVZXBD X11, X11 // 66450f3831db - //TODO: PMOVZXBQ (BX), X2 // 660f383213 - //TODO: PMOVZXBQ (R11), X2 // 66410f383213 - //TODO: PMOVZXBQ X2, X2 // 660f3832d2 - //TODO: PMOVZXBQ X11, X2 // 66410f3832d3 - //TODO: PMOVZXBQ (BX), X11 // 66440f38321b - //TODO: PMOVZXBQ (R11), X11 // 66450f38321b - //TODO: PMOVZXBQ X2, X11 // 66440f3832da - //TODO: PMOVZXBQ X11, X11 // 66450f3832db - //TODO: PMOVZXBW (BX), X2 // 660f383013 - //TODO: PMOVZXBW (R11), X2 // 66410f383013 - //TODO: PMOVZXBW X2, X2 // 660f3830d2 - //TODO: PMOVZXBW X11, X2 // 66410f3830d3 - //TODO: PMOVZXBW (BX), X11 // 66440f38301b - //TODO: PMOVZXBW (R11), X11 // 66450f38301b - //TODO: PMOVZXBW X2, X11 // 66440f3830da - //TODO: PMOVZXBW X11, X11 // 66450f3830db - //TODO: PMOVZXDQ (BX), X2 // 660f383513 - //TODO: PMOVZXDQ (R11), X2 // 66410f383513 - //TODO: PMOVZXDQ X2, X2 // 660f3835d2 - //TODO: PMOVZXDQ X11, X2 // 66410f3835d3 - //TODO: PMOVZXDQ (BX), X11 // 66440f38351b - //TODO: PMOVZXDQ (R11), X11 // 66450f38351b - //TODO: PMOVZXDQ X2, X11 // 66440f3835da - //TODO: PMOVZXDQ X11, X11 // 66450f3835db - //TODO: PMOVZXWD (BX), X2 // 660f383313 - //TODO: PMOVZXWD (R11), X2 // 66410f383313 - //TODO: PMOVZXWD X2, X2 // 660f3833d2 - //TODO: PMOVZXWD X11, X2 // 66410f3833d3 - //TODO: PMOVZXWD (BX), X11 // 66440f38331b - //TODO: PMOVZXWD (R11), X11 // 66450f38331b - //TODO: PMOVZXWD X2, X11 // 66440f3833da - //TODO: PMOVZXWD X11, X11 // 66450f3833db - //TODO: PMOVZXWQ (BX), X2 // 660f383413 - //TODO: PMOVZXWQ (R11), X2 // 66410f383413 - //TODO: PMOVZXWQ X2, X2 // 660f3834d2 - //TODO: PMOVZXWQ X11, X2 // 66410f3834d3 - //TODO: PMOVZXWQ (BX), X11 // 66440f38341b - //TODO: PMOVZXWQ (R11), X11 // 66450f38341b - //TODO: PMOVZXWQ X2, X11 // 66440f3834da - //TODO: PMOVZXWQ X11, X11 // 66450f3834db - //TODO: PMULDQ (BX), X2 // 660f382813 - //TODO: PMULDQ (R11), X2 // 66410f382813 - //TODO: PMULDQ X2, X2 // 660f3828d2 - //TODO: PMULDQ X11, X2 // 66410f3828d3 - //TODO: PMULDQ (BX), X11 // 66440f38281b - //TODO: PMULDQ (R11), X11 // 66450f38281b - //TODO: PMULDQ X2, X11 // 66440f3828da - //TODO: PMULDQ X11, X11 // 66450f3828db + 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 @@ -4085,14 +4085,14 @@ TEXT asmtest(SB),7,$0 PMULHW (R11), X11 // 66450fe51b PMULHW X2, X11 // 66440fe5da PMULHW X11, X11 // 66450fe5db - //TODO: PMULLD (BX), X2 // 660f384013 - //TODO: PMULLD (R11), X2 // 66410f384013 - //TODO: PMULLD X2, X2 // 660f3840d2 - //TODO: PMULLD X11, X2 // 66410f3840d3 - //TODO: PMULLD (BX), X11 // 66440f38401b - //TODO: PMULLD (R11), X11 // 66450f38401b - //TODO: PMULLD X2, X11 // 66440f3840da - //TODO: PMULLD X11, X11 // 66450f3840db + 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 diff --git a/src/cmd/internal/obj/x86/a.out.go b/src/cmd/internal/obj/x86/a.out.go index 6c7eaa12e67..26dc7e990aa 100644 --- a/src/cmd/internal/obj/x86/a.out.go +++ b/src/cmd/internal/obj/x86/a.out.go @@ -601,15 +601,15 @@ const ( APADDUSB APADDUSW APADDW + APAND APANDB APANDL + APANDN APANDSB APANDSW APANDUSB APANDUSW APANDW - APAND - APANDN APAVGB APAVGW APCMPEQB @@ -618,10 +618,10 @@ const ( APCMPGTB APCMPGTL APCMPGTW - APEXTRW APEXTRB APEXTRD APEXTRQ + APEXTRW APFACC APFADD APFCMPEQ @@ -633,42 +633,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 diff --git a/src/cmd/internal/obj/x86/anames.go b/src/cmd/internal/obj/x86/anames.go index 70ac5d97637..682c9e0c990 100644 --- a/src/cmd/internal/obj/x86/anames.go +++ b/src/cmd/internal/obj/x86/anames.go @@ -550,15 +550,15 @@ var Anames = []string{ "PADDUSB", "PADDUSW", "PADDW", + "PAND", "PANDB", "PANDL", + "PANDN", "PANDSB", "PANDSW", "PANDUSB", "PANDUSW", "PANDW", - "PAND", - "PANDN", "PAVGB", "PAVGW", "PCMPEQB", @@ -567,10 +567,10 @@ var Anames = []string{ "PCMPGTB", "PCMPGTL", "PCMPGTW", - "PEXTRW", "PEXTRB", "PEXTRD", "PEXTRQ", + "PEXTRW", "PFACC", "PFADD", "PFCMPEQ", @@ -582,42 +582,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", diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go index c19c03826c1..2c31d278274 100644 --- a/src/cmd/internal/obj/x86/asm6.go +++ b/src/cmd/internal/obj/x86/asm6.go @@ -222,6 +222,7 @@ const ( 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 @@ -675,6 +676,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}, @@ -817,6 +822,10 @@ 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 @@ -873,6 +882,11 @@ var yvex_xxmyxm = []ytab{ {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 @@ -1149,6 +1163,7 @@ var optab = {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}}, @@ -1293,6 +1308,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}}, @@ -1303,9 +1325,23 @@ 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}}, @@ -3292,6 +3328,12 @@ func doasm(ctxt *obj.Link, p *obj.Prog) { 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) From 0bae38e094098237c12dbb7344371f35e9663905 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Sun, 24 Jan 2016 00:44:23 -0500 Subject: [PATCH 037/128] cmd/asm: add amd64 PDEP, PEXT, and related integer VEX instructions Requested off-list. Trivial to add and more importantly trivial to test. ANDNL ANDNQ BEXTRL BEXTRQ BZHIL BZHIQ MULXL MULXQ PDEPL PDEPQ PEXTL PEXTQ SARXL SARXQ SHRXL SHRXQ Change-Id: I3d46a0f653b81dd003ff6d2a394d8ce96a573b63 Reviewed-on: https://go-review.googlesource.com/18857 Reviewed-by: Rob Pike --- src/cmd/asm/internal/asm/testdata/amd64enc.s | 312 +++++++++---------- src/cmd/internal/obj/x86/a.out.go | 24 ++ src/cmd/internal/obj/x86/anames.go | 24 ++ src/cmd/internal/obj/x86/asm6.go | 34 ++ 4 files changed, 238 insertions(+), 156 deletions(-) diff --git a/src/cmd/asm/internal/asm/testdata/amd64enc.s b/src/cmd/asm/internal/asm/testdata/amd64enc.s index 5c44d50fade..63ba7cafea1 100644 --- a/src/cmd/asm/internal/asm/testdata/amd64enc.s +++ b/src/cmd/asm/internal/asm/testdata/amd64enc.s @@ -370,22 +370,22 @@ TEXT asmtest(SB),7,$0 ANDB (R11), DL // 412213 ANDB (BX), R11 // 44221b ANDB (R11), R11 // 45221b - //TODO: ANDNL (BX), R9D, DX // c4e230f213 - //TODO: ANDNL (R11), R9D, DX // c4c230f213 - //TODO: ANDNL DX, R9D, DX // c4e230f2d2 - //TODO: ANDNL R11, R9D, DX // c4c230f2d3 - //TODO: ANDNL (BX), R9D, R11 // c46230f21b - //TODO: ANDNL (R11), R9D, R11 // c44230f21b - //TODO: ANDNL DX, R9D, R11 // c46230f2da - //TODO: ANDNL R11, R9D, R11 // c44230f2db - //TODO: ANDNQ (BX), R14, DX // c4e288f213 - //TODO: ANDNQ (R11), R14, DX // c4c288f213 - //TODO: ANDNQ DX, R14, DX // c4e288f2d2 - //TODO: ANDNQ R11, R14, DX // c4c288f2d3 - //TODO: ANDNQ (BX), R14, R11 // c46288f21b - //TODO: ANDNQ (R11), R14, R11 // c44288f21b - //TODO: ANDNQ DX, R14, R11 // c46288f2da - //TODO: ANDNQ R11, R14, R11 // c44288f2db + 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 @@ -418,22 +418,22 @@ TEXT asmtest(SB),7,$0 //TODO: ANDPS (R11), X11 // 450f541b //TODO: ANDPS X2, X11 // 440f54da //TODO: ANDPS X11, X11 // 450f54db - //TODO: BEXTRL R9D, (BX), DX // c4e230f713 - //TODO: BEXTRL R9D, (R11), DX // c4c230f713 - //TODO: BEXTRL R9D, DX, DX // c4e230f7d2 - //TODO: BEXTRL R9D, R11, DX // c4c230f7d3 - //TODO: BEXTRL R9D, (BX), R11 // c46230f71b - //TODO: BEXTRL R9D, (R11), R11 // c44230f71b - //TODO: BEXTRL R9D, DX, R11 // c46230f7da - //TODO: BEXTRL R9D, R11, R11 // c44230f7db - //TODO: BEXTRQ R14, (BX), DX // c4e288f713 - //TODO: BEXTRQ R14, (R11), DX // c4c288f713 - //TODO: BEXTRQ R14, DX, DX // c4e288f7d2 - //TODO: BEXTRQ R14, R11, DX // c4c288f7d3 - //TODO: BEXTRQ R14, (BX), R11 // c46288f71b - //TODO: BEXTRQ R14, (R11), R11 // c44288f71b - //TODO: BEXTRQ R14, DX, R11 // c46288f7da - //TODO: BEXTRQ R14, R11, R11 // c44288f7db + 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 @@ -466,26 +466,26 @@ TEXT asmtest(SB),7,$0 //TODO: BLENDVPS XMM0, (R11), X11 // 66450f38141b //TODO: BLENDVPS XMM0, X2, X11 // 66440f3814da //TODO: BLENDVPS XMM0, X11, X11 // 66450f3814db - //TODO: BLSIL (BX), R9D // c4e230f31b - //TODO: BLSIL (R11), R9D // c4c230f31b - //TODO: BLSIL DX, R9D // c4e230f3da - //TODO: BLSIL R11, R9D // c4c230f3db + //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), R9D // c4e230f313 - //TODO: BLSMSKL (R11), R9D // c4c230f313 - //TODO: BLSMSKL DX, R9D // c4e230f3d2 - //TODO: BLSMSKL R11, R9D // c4c230f3d3 + //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), R9D // c4e230f30b - //TODO: BLSRL (R11), R9D // c4c230f30b - //TODO: BLSRL DX, R9D // c4e230f3ca - //TODO: BLSRL R11, R9D // c4c230f3cb + //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 @@ -736,22 +736,22 @@ TEXT asmtest(SB),7,$0 BTSQ R11, DX // 4c0fabda BTSQ DX, R11 // 490fabd3 BTSQ R11, R11 // 4d0fabdb - //TODO: BZHIL R9D, (BX), DX // c4e230f513 - //TODO: BZHIL R9D, (R11), DX // c4c230f513 - //TODO: BZHIL R9D, DX, DX // c4e230f5d2 - //TODO: BZHIL R9D, R11, DX // c4c230f5d3 - //TODO: BZHIL R9D, (BX), R11 // c46230f51b - //TODO: BZHIL R9D, (R11), R11 // c44230f51b - //TODO: BZHIL R9D, DX, R11 // c46230f5da - //TODO: BZHIL R9D, R11, R11 // c44230f5db - //TODO: BZHIQ R14, (BX), DX // c4e288f513 - //TODO: BZHIQ R14, (R11), DX // c4c288f513 - //TODO: BZHIQ R14, DX, DX // c4e288f5d2 - //TODO: BZHIQ R14, R11, DX // c4c288f5d3 - //TODO: BZHIQ R14, (BX), R11 // c46288f51b - //TODO: BZHIQ R14, (R11), R11 // c44288f51b - //TODO: BZHIQ R14, DX, R11 // c46288f5da - //TODO: BZHIQ R14, R11, R11 // c44288f5db + 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 @@ -2911,22 +2911,22 @@ TEXT asmtest(SB),7,$0 MULSS (R11), X11 // f3450f591b MULSS X2, X11 // f3440f59da MULSS X11, X11 // f3450f59db - //TODO: MULXL (BX), R9D, DX // c4e233f613 - //TODO: MULXL (R11), R9D, DX // c4c233f613 - //TODO: MULXL DX, R9D, DX // c4e233f6d2 - //TODO: MULXL R11, R9D, DX // c4c233f6d3 - //TODO: MULXL (BX), R9D, R11 // c46233f61b - //TODO: MULXL (R11), R9D, R11 // c44233f61b - //TODO: MULXL DX, R9D, R11 // c46233f6da - //TODO: MULXL R11, R9D, R11 // c44233f6db - //TODO: MULXQ (BX), R14, DX // c4e28bf613 - //TODO: MULXQ (R11), R14, DX // c4c28bf613 - //TODO: MULXQ DX, R14, DX // c4e28bf6d2 - //TODO: MULXQ R11, R14, DX // c4c28bf6d3 - //TODO: MULXQ (BX), R14, R11 // c4628bf61b - //TODO: MULXQ (R11), R14, R11 // c4428bf61b - //TODO: MULXQ DX, R14, R11 // c4628bf6da - //TODO: MULXQ R11, R14, R11 // c4428bf6db + 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 @@ -3553,38 +3553,38 @@ TEXT asmtest(SB),7,$0 //TODO: PCMPISTRM $7, (R11), X11 // 66450f3a621b07 //TODO: PCMPISTRM $7, X2, X11 // 66440f3a62da07 //TODO: PCMPISTRM $7, X11, X11 // 66450f3a62db07 - //TODO: PDEPL (BX), R9D, DX // c4e233f513 - //TODO: PDEPL (R11), R9D, DX // c4c233f513 - //TODO: PDEPL DX, R9D, DX // c4e233f5d2 - //TODO: PDEPL R11, R9D, DX // c4c233f5d3 - //TODO: PDEPL (BX), R9D, R11 // c46233f51b - //TODO: PDEPL (R11), R9D, R11 // c44233f51b - //TODO: PDEPL DX, R9D, R11 // c46233f5da - //TODO: PDEPL R11, R9D, R11 // c44233f5db - //TODO: PDEPQ (BX), R14, DX // c4e28bf513 - //TODO: PDEPQ (R11), R14, DX // c4c28bf513 - //TODO: PDEPQ DX, R14, DX // c4e28bf5d2 - //TODO: PDEPQ R11, R14, DX // c4c28bf5d3 - //TODO: PDEPQ (BX), R14, R11 // c4628bf51b - //TODO: PDEPQ (R11), R14, R11 // c4428bf51b - //TODO: PDEPQ DX, R14, R11 // c4628bf5da - //TODO: PDEPQ R11, R14, R11 // c4428bf5db - //TODO: PEXTL (BX), R9D, DX // c4e232f513 - //TODO: PEXTL (R11), R9D, DX // c4c232f513 - //TODO: PEXTL DX, R9D, DX // c4e232f5d2 - //TODO: PEXTL R11, R9D, DX // c4c232f5d3 - //TODO: PEXTL (BX), R9D, R11 // c46232f51b - //TODO: PEXTL (R11), R9D, R11 // c44232f51b - //TODO: PEXTL DX, R9D, R11 // c46232f5da - //TODO: PEXTL R11, R9D, R11 // c44232f5db - //TODO: PEXTQ (BX), R14, DX // c4e28af513 - //TODO: PEXTQ (R11), R14, DX // c4c28af513 - //TODO: PEXTQ DX, R14, DX // c4e28af5d2 - //TODO: PEXTQ R11, R14, DX // c4c28af5d3 - //TODO: PEXTQ (BX), R14, R11 // c4628af51b - //TODO: PEXTQ (R11), R14, R11 // c4428af51b - //TODO: PEXTQ DX, R14, R11 // c4628af5da - //TODO: PEXTQ R11, R14, R11 // c4428af5db + 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 @@ -5122,22 +5122,22 @@ TEXT asmtest(SB),7,$0 SARB $7, (R11) // 41c03b07 SARB $7, DL // c0fa07 SARB $7, R11 // 41c0fb07 - //TODO: SARXL R9D, (BX), DX // c4e232f713 - //TODO: SARXL R9D, (R11), DX // c4c232f713 - //TODO: SARXL R9D, DX, DX // c4e232f7d2 - //TODO: SARXL R9D, R11, DX // c4c232f7d3 - //TODO: SARXL R9D, (BX), R11 // c46232f71b - //TODO: SARXL R9D, (R11), R11 // c44232f71b - //TODO: SARXL R9D, DX, R11 // c46232f7da - //TODO: SARXL R9D, R11, R11 // c44232f7db - //TODO: SARXQ R14, (BX), DX // c4e28af713 - //TODO: SARXQ R14, (R11), DX // c4c28af713 - //TODO: SARXQ R14, DX, DX // c4e28af7d2 - //TODO: SARXQ R14, R11, DX // c4c28af7d3 - //TODO: SARXQ R14, (BX), R11 // c4628af71b - //TODO: SARXQ R14, (R11), R11 // c4428af71b - //TODO: SARXQ R14, DX, R11 // c4628af7da - //TODO: SARXQ R14, R11, R11 // c4428af7db + 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 @@ -5385,22 +5385,22 @@ TEXT asmtest(SB),7,$0 SHLQ $7, R11, DX // 4c0fa4da07 SHLQ $7, DX, R11 // 490fa4d307 SHLQ $7, R11, R11 // 4d0fa4db07 - //TODO: SHLXL R9D, (BX), DX // c4e231f713 - //TODO: SHLXL R9D, (R11), DX // c4c231f713 - //TODO: SHLXL R9D, DX, DX // c4e231f7d2 - //TODO: SHLXL R9D, R11, DX // c4c231f7d3 - //TODO: SHLXL R9D, (BX), R11 // c46231f71b - //TODO: SHLXL R9D, (R11), R11 // c44231f71b - //TODO: SHLXL R9D, DX, R11 // c46231f7da - //TODO: SHLXL R9D, R11, R11 // c44231f7db - //TODO: SHLXQ R14, (BX), DX // c4e289f713 - //TODO: SHLXQ R14, (R11), DX // c4c289f713 - //TODO: SHLXQ R14, DX, DX // c4e289f7d2 - //TODO: SHLXQ R14, R11, DX // c4c289f7d3 - //TODO: SHLXQ R14, (BX), R11 // c46289f71b - //TODO: SHLXQ R14, (R11), R11 // c44289f71b - //TODO: SHLXQ R14, DX, R11 // c46289f7da - //TODO: SHLXQ R14, R11, R11 // c44289f7db + 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 @@ -5497,22 +5497,22 @@ TEXT asmtest(SB),7,$0 SHRQ $7, R11, DX // 4c0facda07 SHRQ $7, DX, R11 // 490facd307 SHRQ $7, R11, R11 // 4d0facdb07 - //TODO: SHRXL R9D, (BX), DX // c4e233f713 - //TODO: SHRXL R9D, (R11), DX // c4c233f713 - //TODO: SHRXL R9D, DX, DX // c4e233f7d2 - //TODO: SHRXL R9D, R11, DX // c4c233f7d3 - //TODO: SHRXL R9D, (BX), R11 // c46233f71b - //TODO: SHRXL R9D, (R11), R11 // c44233f71b - //TODO: SHRXL R9D, DX, R11 // c46233f7da - //TODO: SHRXL R9D, R11, R11 // c44233f7db - //TODO: SHRXQ R14, (BX), DX // c4e28bf713 - //TODO: SHRXQ R14, (R11), DX // c4c28bf713 - //TODO: SHRXQ R14, DX, DX // c4e28bf7d2 - //TODO: SHRXQ R14, R11, DX // c4c28bf7d3 - //TODO: SHRXQ R14, (BX), R11 // c4628bf71b - //TODO: SHRXQ R14, (R11), R11 // c4428bf71b - //TODO: SHRXQ R14, DX, R11 // c4628bf7da - //TODO: SHRXQ R14, R11, R11 // c4428bf7db + 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 diff --git a/src/cmd/internal/obj/x86/a.out.go b/src/cmd/internal/obj/x86/a.out.go index 26dc7e990aa..efce9867d52 100644 --- a/src/cmd/internal/obj/x86/a.out.go +++ b/src/cmd/internal/obj/x86/a.out.go @@ -510,10 +510,22 @@ const ( AADDPS AADDSD AADDSS + AANDNL + AANDNQ AANDNPD AANDNPS AANDPD AANDPS + ABEXTRL + ABEXTRQ + ABLSIL + ABLSIQ + ABLSMSKL + ABLSMSKQ + ABLSRL + ABLSRQ + ABZHIL + ABZHIQ ACMPPD ACMPPS ACMPSD @@ -588,6 +600,8 @@ const ( AMULPS AMULSD AMULSS + AMULXL + AMULXQ AORPD AORPS APACKSSLW @@ -618,6 +632,10 @@ const ( APCMPGTB APCMPGTL APCMPGTW + APDEPL + APDEPQ + APEXTL + APEXTQ APEXTRB APEXTRD APEXTRQ @@ -714,6 +732,12 @@ const ( ARCPSS ARSQRTPS ARSQRTSS + ASARXL + ASARXQ + ASHLXL + ASHLXQ + ASHRXL + ASHRXQ ASHUFPD ASHUFPS ASQRTPD diff --git a/src/cmd/internal/obj/x86/anames.go b/src/cmd/internal/obj/x86/anames.go index 682c9e0c990..b1c3f00f7c9 100644 --- a/src/cmd/internal/obj/x86/anames.go +++ b/src/cmd/internal/obj/x86/anames.go @@ -459,10 +459,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", @@ -537,6 +549,8 @@ var Anames = []string{ "MULPS", "MULSD", "MULSS", + "MULXL", + "MULXQ", "ORPD", "ORPS", "PACKSSLW", @@ -567,6 +581,10 @@ var Anames = []string{ "PCMPGTB", "PCMPGTL", "PCMPGTW", + "PDEPL", + "PDEPQ", + "PEXTL", + "PEXTQ", "PEXTRB", "PEXTRD", "PEXTRQ", @@ -663,6 +681,12 @@ var Anames = []string{ "RCPSS", "RSQRTPS", "RSQRTSS", + "SARXL", + "SARXQ", + "SHLXL", + "SHLXQ", + "SHRXL", + "SHRXQ", "SHUFPD", "SHUFPS", "SQRTPD", diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go index 2c31d278274..f00be91b005 100644 --- a/src/cmd/internal/obj/x86/asm6.go +++ b/src/cmd/internal/obj/x86/asm6.go @@ -207,6 +207,7 @@ const ( Zbyte Zvex_rm_v_r Zvex_r_v_rm + Zvex_v_rm_r Zmax ) @@ -850,6 +851,16 @@ var yvex_xy3 = []ytab{ {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}, @@ -1669,6 +1680,25 @@ var optab = {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}}, {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}}, @@ -3542,6 +3572,10 @@ func doasm(ctxt *obj.Link, p *obj.Prog) { 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) From 970ce1c866f767796ca36f5a3ac37c7222bf31d9 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Sat, 23 Jan 2016 23:22:49 -0500 Subject: [PATCH 038/128] encoding/xml: update docs for Token Fixes #13757. Change-Id: I1b52593df8df0e98ce7342767eb34eccecc11761 Reviewed-on: https://go-review.googlesource.com/18854 Run-TryBot: Russ Cox TryBot-Result: Gobot Gobot Reviewed-by: Brad Fitzpatrick --- src/encoding/xml/xml.go | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) 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 From 544f28a25ec9421d52bbdd7c6272b4f1d4067964 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Sun, 24 Jan 2016 11:02:19 -0500 Subject: [PATCH 039/128] misc/cgo/test: fix test on darwin/386 with cgo enabled Apparently the darwin/386 builder does not enable cgo. This failure turned up running GOARCH=386 GOHOSTARCH=386 ./all.bash on my Mac. Change-Id: Ia2487c4fd85d4b0f9f564880f22d9fde379946c3 Reviewed-on: https://go-review.googlesource.com/18859 Reviewed-by: Ian Lance Taylor --- misc/cgo/test/sigaltstack.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/misc/cgo/test/sigaltstack.go b/misc/cgo/test/sigaltstack.go index 787653c4825..178e71c9b70 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. From 9d6427d8992b05445029f95c9555820675dd2e3e Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Sun, 24 Jan 2016 01:33:16 -0500 Subject: [PATCH 040/128] cmd/asm: reject foo(SB)(AX) instead of silently treating as foo(SB) Add test for assembly errors, to verify fix. Make sure invalid instruction errors are printed just once (was printing them once per span iteration, so typically twice). Fixes #13282. Change-Id: Id5f66f80a80b3bc4832e00084b0a91f1afec7f8f Reviewed-on: https://go-review.googlesource.com/18858 Reviewed-by: Rob Pike --- src/cmd/asm/internal/asm/endtoend_test.go | 114 +++++++++++++++++- .../asm/internal/asm/testdata/amd64error.s | 7 ++ src/cmd/asm/main.go | 2 +- src/cmd/compile/internal/gc/lex.go | 2 +- src/cmd/internal/obj/link.go | 8 +- src/cmd/internal/obj/x86/asm6.go | 9 ++ 6 files changed, 135 insertions(+), 7 deletions(-) create mode 100644 src/cmd/asm/internal/asm/testdata/amd64error.s diff --git a/src/cmd/asm/internal/asm/endtoend_test.go b/src/cmd/asm/internal/asm/endtoend_test.go index 8f5d56d53a5..4bc7e2fb749 100644 --- a/src/cmd/asm/internal/asm/endtoend_test.go +++ b/src/cmd/asm/internal/asm/endtoend_test.go @@ -10,6 +10,7 @@ import ( "io/ioutil" "os" "path/filepath" + "regexp" "sort" "strconv" "strings" @@ -35,11 +36,10 @@ func testEndToEnd(t *testing.T, goarch, file string) { ctxt.Bso = obj.Binitw(os.Stdout) defer ctxt.Bso.Flush() failed := false - ctxt.Diag = func(format string, args ...interface{}) { + ctxt.DiagFunc = func(format string, args ...interface{}) { failed = true t.Errorf(format, args...) } - obj.Binitw(ioutil.Discard) pList.Firstpc, ok = parser.Parse() if !ok || failed { t.Errorf("asm: %s assembly failed", goarch) @@ -175,7 +175,7 @@ Diff: top := pList.Firstpc var text *obj.LSym ok = true - ctxt.Diag = func(format string, args ...interface{}) { + ctxt.DiagFunc = func(format string, args ...interface{}) { t.Errorf(format, args...) ok = false } @@ -250,8 +250,110 @@ func isHexes(s string) bool { return true } +// It would be nice if the error messages began with +// the standard file:line: prefix, +// but that's not where we are today. +// It might be at the beginning but it might be in the middle of the printed instruction. +var fileLineRE = regexp.MustCompile(`(?:^|\()(testdata[/\\][0-9a-z]+\.s:[0-9]+)(?:$|\))`) + +// Same as in test/run.go +var ( + errRE = regexp.MustCompile(`// ERROR ?(.*)`) + errQuotesRE = regexp.MustCompile(`"([^"]*)"`) +) + +func testErrors(t *testing.T, goarch, file string) { + lex.InitHist() + input := filepath.Join("testdata", file+".s") + architecture, ctxt := setArch(goarch) + lexer := lex.NewLexer(input, ctxt) + parser := NewParser(ctxt, architecture, lexer) + pList := obj.Linknewplist(ctxt) + var ok bool + testOut = new(bytes.Buffer) // The assembler writes test output to this buffer. + ctxt.Bso = obj.Binitw(os.Stdout) + defer ctxt.Bso.Flush() + failed := false + var errBuf bytes.Buffer + ctxt.DiagFunc = func(format string, args ...interface{}) { + failed = true + s := fmt.Sprintf(format, args...) + if !strings.HasSuffix(s, "\n") { + s += "\n" + } + errBuf.WriteString(s) + } + pList.Firstpc, ok = parser.Parse() + obj.Flushplist(ctxt) + if ok && !failed { + t.Errorf("asm: %s had no errors", goarch) + } + + errors := map[string]string{} + for _, line := range strings.Split(errBuf.String(), "\n") { + if line == "" || strings.HasPrefix(line, "\t") { + continue + } + m := fileLineRE.FindStringSubmatch(line) + if m == nil { + t.Errorf("unexpected error: %v", line) + continue + } + fileline := m[1] + if errors[fileline] != "" { + t.Errorf("multiple errors on %s:\n\t%s\n\t%s", fileline, errors[fileline], line) + continue + } + errors[fileline] = line + } + + // Reconstruct expected errors by independently "parsing" the input. + data, err := ioutil.ReadFile(input) + if err != nil { + t.Error(err) + return + } + lineno := 0 + lines := strings.Split(string(data), "\n") + for _, line := range lines { + lineno++ + + fileline := fmt.Sprintf("%s:%d", input, lineno) + if m := errRE.FindStringSubmatch(line); m != nil { + all := m[1] + mm := errQuotesRE.FindAllStringSubmatch(all, -1) + if len(mm) != 1 { + t.Errorf("%s: invalid errorcheck line:\n%s", fileline, line) + } else if err := errors[fileline]; err == "" { + t.Errorf("%s: missing error, want %s", fileline, all) + } else if !strings.Contains(err, mm[0][1]) { + t.Errorf("%s: wrong error for %s:\n%s", fileline, all, err) + } + } else { + if errors[fileline] != "" { + t.Errorf("unexpected error on %s: %v", fileline, errors[fileline]) + } + } + delete(errors, fileline) + } + var extra []string + for key := range errors { + extra = append(extra, key) + } + sort.Strings(extra) + for _, fileline := range extra { + t.Errorf("unexpected error on %s: %v", fileline, errors[fileline]) + } +} + func Test386EndToEnd(t *testing.T) { - testEndToEnd(t, "386", "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) { @@ -276,6 +378,10 @@ 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", "mips64") } 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..9895b54ab08 --- /dev/null +++ b/src/cmd/asm/internal/asm/testdata/amd64error.s @@ -0,0 +1,7 @@ +// 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" + RET diff --git a/src/cmd/asm/main.go b/src/cmd/asm/main.go index 528481c1329..f48050c1378 100644 --- a/src/cmd/asm/main.go +++ b/src/cmd/asm/main.go @@ -54,7 +54,7 @@ func main() { lexer := lex.NewLexer(flag.Arg(0), ctxt) parser := asm.NewParser(ctxt, architecture, lexer) diag := false - ctxt.Diag = func(format string, args ...interface{}) { + ctxt.DiagFunc = func(format string, args ...interface{}) { diag = true log.Printf(format, args...) } diff --git a/src/cmd/compile/internal/gc/lex.go b/src/cmd/compile/internal/gc/lex.go index 8d1d2e25944..b9c27357bb6 100644 --- a/src/cmd/compile/internal/gc/lex.go +++ b/src/cmd/compile/internal/gc/lex.go @@ -105,7 +105,7 @@ func Main() { Thearch.Linkarchinit() Ctxt = obj.Linknew(Thearch.Thelinkarch) - Ctxt.Diag = Yyerror + Ctxt.DiagFunc = Yyerror Ctxt.Bso = &bstdout bstdout = *obj.Binitw(os.Stdout) diff --git a/src/cmd/internal/obj/link.go b/src/cmd/internal/obj/link.go index bc898235c12..762a49ecf2a 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/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go index f00be91b005..fdc25faf98a 100644 --- a/src/cmd/internal/obj/x86/asm6.go +++ b/src/cmd/internal/obj/x86/asm6.go @@ -1856,6 +1856,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++ { @@ -1968,6 +1969,9 @@ func span6(ctxt *obj.Link, s *obj.LSym) { if loop == 0 { break } + if ctxt.Errors > errors { + return + } } if ctxt.Headtype == obj.Hnacl { @@ -2294,6 +2298,11 @@ func oclass(ctxt *obj.Link, p *obj.Prog, a *obj.Addr) int { return Yxxx case obj.TYPE_MEM: + if a.Name != obj.NAME_NONE { + if ctxt.Asmode == 64 && (a.Reg != REG_NONE || a.Index != REG_NONE || a.Scale != 0) { + return Yxxx + } + } return Ym case obj.TYPE_ADDR: From 3415d0c49ddb6c48a90919eb023c71c7e82c3189 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Mon, 18 Jan 2016 21:23:33 -0800 Subject: [PATCH 041/128] cmd/go: fix handling of asm files for -compiler=gccgo Pass -c to generate an object. Pass GOPKGPATH as a symbol, not a string. Pass -xassembler-with-cpp so that the preprocessor is run. Change-Id: I84690a73cc580bb05724ed07c120cec9cfd5e48b Reviewed-on: https://go-review.googlesource.com/18733 Run-TryBot: Ian Lance Taylor TryBot-Result: Gobot Gobot Reviewed-by: Russ Cox --- src/cmd/go/build.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/cmd/go/build.go b/src/cmd/go/build.go index 6a8edaf6d25..e127524ceb3 100644 --- a/src/cmd/go/build.go +++ b/src/cmd/go/build.go @@ -2568,11 +2568,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 { From 801bebefa91205b0b69f2458701aac8169294884 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Thu, 21 Jan 2016 21:56:38 -0800 Subject: [PATCH 042/128] runtime: always install new signal stack on NetBSD and DragonFly On NetBSD and DragonFly a newly created thread inherits the signal stack of the creating thread. That means that in a cgo program a C thread created using pthread_create will get the signal stack of the creating thread, most likely a Go thread. This will then lead to chaos if two signals occur simultaneously. We can't fix the general case. But we can fix the case of a C thread that calls a Go function, by installing a new signal stack and then dropping it when we return to C. That will break the case of a C thread that calls sigaltstack and then calls Go, because we will drop the C thread's alternate signal stack as we return from Go. Still, this is the 1.5 behavior. And what else can we do? Fixes #14051. Fixes #14052. Fixes #14067. Change-Id: Iee286ca50b50ec712a4d929c7121c35e2383a7b9 Reviewed-on: https://go-review.googlesource.com/18835 Reviewed-by: Brad Fitzpatrick Reviewed-by: Mikio Hara Reviewed-by: Russ Cox --- src/runtime/os1_dragonfly.go | 27 +++++++++++---------------- src/runtime/os1_netbsd.go | 27 +++++++++++---------------- 2 files changed, 22 insertions(+), 32 deletions(-) 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 9ab39ba97d9..eab8eb87024 100644 --- a/src/runtime/os1_netbsd.go +++ b/src/runtime/os1_netbsd.go @@ -172,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 From 3caf4e05cf337fa9b395dd887aa3e8d2e26eecdf Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Sun, 24 Jan 2016 16:33:47 +0000 Subject: [PATCH 043/128] net/http: check max size of HTTP chunks MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Thanks to Régis Leroy for noticing. Change-Id: I5ca2402efddab4e63d884a9d315fc1394e514cb7 Reviewed-on: https://go-review.googlesource.com/18871 Reviewed-by: Russ Cox Run-TryBot: Brad Fitzpatrick TryBot-Result: Gobot Gobot --- src/net/http/internal/chunked.go | 7 +++-- src/net/http/internal/chunked_test.go | 40 +++++++++++++++++++-------- 2 files changed, 33 insertions(+), 14 deletions(-) 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) + } + } } } From cedbbfaa45fac82a0088b3163c7137e814020a53 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Mon, 25 Jan 2016 10:23:38 -0800 Subject: [PATCH 044/128] runtime: update heap dumper header to 1.6. Change-Id: Ic2a326d41783fb591148748dbcccfd3855091437 Reviewed-on: https://go-review.googlesource.com/18912 Reviewed-by: Brad Fitzpatrick --- src/runtime/heapdump.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 From 7688ffe1341a534d42367410f4a4bef0a31a7f37 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Mon, 25 Jan 2016 09:54:39 -0800 Subject: [PATCH 045/128] runtime/pprof: document SetCPUProfile with c-archive/c-shared When using c-archive/c-shared, the signal handler for SIGPROF will not be installed, which means that runtime/pprof.StartCPUProfile won't work. There is no really good solution here, as the main program may want to do its own profiling. For now, just document that runtime/pprof doesn't work as expected, but that it will work if you use Notify to install the Go signal handler. Fixes #14043. Change-Id: I7ff7a01df6ef7f63a7f050aac3674d640a246fb4 Reviewed-on: https://go-review.googlesource.com/18911 Run-TryBot: Ian Lance Taylor TryBot-Result: Gobot Gobot Reviewed-by: David Crawshaw --- src/runtime/pprof/pprof.go | 8 ++++++++ 1 file changed, 8 insertions(+) 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 From db5cb1d8cdf957c96fa44c340fb0fc53f2b3231e Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Mon, 25 Jan 2016 21:20:17 +0000 Subject: [PATCH 046/128] net/http: update bundled http2 Updates x/net/http2 to git rev 2e9cee70 for https://golang.org/cl/18801 Change-Id: I4689c5704bb0b12d569925f81c3e699857ea463e Reviewed-on: https://go-review.googlesource.com/18931 Reviewed-by: Brad Fitzpatrick Run-TryBot: Brad Fitzpatrick TryBot-Result: Gobot Gobot --- src/net/http/h2_bundle.go | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-) diff --git a/src/net/http/h2_bundle.go b/src/net/http/h2_bundle.go index bdbdadb5b28..21106419559 100644 --- a/src/net/http/h2_bundle.go +++ b/src/net/http/h2_bundle.go @@ -2098,6 +2098,8 @@ func http2validHeaderFieldName(v string) bool { // 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 @@ -2117,7 +2119,7 @@ func http2validHeaderFieldName(v string) bool { // 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' { + if b := v[i]; b < ' ' && b != '\t' || b == 0x7f { return false } } From 071fcd1ae919775149d43a01379dc8874cbe3d73 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Wed, 20 Jan 2016 19:00:32 +0000 Subject: [PATCH 047/128] net/http/httputil: clarify docs on the Dump functions Also don't nil out the Request or Response Body on error. Just leave it in its previous broken state. The docs now say it's undefined, but it always was. Fixes #14036 Change-Id: I7fe175a36cbc01b4158f4dffacd8733b2ffa9999 Reviewed-on: https://go-review.googlesource.com/18726 Reviewed-by: Rob Pike --- src/net/http/httputil/dump.go | 29 ++++++++++++++++++----------- 1 file changed, 18 insertions(+), 11 deletions(-) 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) From 99fa8c38393419fab1452ba5b157787b98f4497e Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Sun, 24 Jan 2016 22:59:45 +0000 Subject: [PATCH 048/128] net/http: don't retain *http.Request in Transport's HTTP/2 path Fixes #14084 Change-Id: Icbef5678ab3c4fd7eed2693006c47aca6d831d90 Reviewed-on: https://go-review.googlesource.com/18873 Reviewed-by: Keith Randall Reviewed-by: Austin Clements Run-TryBot: Brad Fitzpatrick TryBot-Result: Gobot Gobot --- src/net/http/clientserver_test.go | 42 +++++++++++++++++++++++++++++++ src/net/http/transport.go | 4 ++- 2 files changed, 45 insertions(+), 1 deletion(-) diff --git a/src/net/http/clientserver_test.go b/src/net/http/clientserver_test.go index 9c1aa7920e3..9b581e73117 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,47 @@ 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_h1(t *testing.T) { testTransportGCRequest(t, h1Mode) } +func TestTransportGCRequest_h2(t *testing.T) { testTransportGCRequest(t, h2Mode) } +func testTransportGCRequest(t *testing.T, h2 bool) { + defer afterTest(t) + cst := newClientServerTest(t, h2, HandlerFunc(func(w ResponseWriter, r *Request) { + ioutil.ReadAll(r.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/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] From 0408ca7de12d72025d40c4d28fd8d9fb142b3c87 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Mon, 25 Jan 2016 15:22:03 -0800 Subject: [PATCH 049/128] runtime: don't check sigaltstack on darwin/{arm,arm64} Use of the alternate signal stack on darwin/{arm,arm64} is reportedly buggy, and the runtime function sigaltstack does nothing. So don't check the sigaltstack result to decide how to handle the signal stack. Fixes #14070. Change-Id: Ie97ede8895fad721e3acc79225f2cafcbe1f3a81 Reviewed-on: https://go-review.googlesource.com/18940 TryBot-Result: Gobot Gobot Reviewed-by: Minux Ma --- src/runtime/os1_darwin.go | 33 +++++++++++++++++++-------------- 1 file changed, 19 insertions(+), 14 deletions(-) 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 From 295ec4f6f8f1eb39ddb97933298351cd57b2b088 Mon Sep 17 00:00:00 2001 From: Mikio Hara Date: Tue, 26 Jan 2016 16:35:52 +0900 Subject: [PATCH 050/128] cmd/go/testdata: fix nits in test Change-Id: I85fa5e672a476098f8711dcbb5b20ea1a3fa630d Reviewed-on: https://go-review.googlesource.com/18953 Reviewed-by: Ian Lance Taylor --- src/cmd/go/testdata/src/vend/hello/hello_test.go | 2 +- src/cmd/go/testdata/src/vend/hello/hellox_test.go | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) 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) } } From e6347659410454cfabc4f4bc04fe37e538f472e8 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Sun, 24 Jan 2016 15:20:36 -0500 Subject: [PATCH 051/128] cmd/asm: add amd64 HADDPD/HADDPS Was part of #13822 but not in the first message, so I missed it. Fixes #13822 again. Change-Id: I775004fa8d47b6af293124605521ec396573e267 Reviewed-on: https://go-review.googlesource.com/18900 Run-TryBot: Russ Cox TryBot-Result: Gobot Gobot Reviewed-by: Brad Fitzpatrick --- src/cmd/asm/internal/asm/testdata/amd64enc.s | 64 ++++++++++---------- src/cmd/internal/obj/x86/a.out.go | 4 ++ src/cmd/internal/obj/x86/anames.go | 4 ++ src/cmd/internal/obj/x86/asm6.go | 4 ++ 4 files changed, 44 insertions(+), 32 deletions(-) diff --git a/src/cmd/asm/internal/asm/testdata/amd64enc.s b/src/cmd/asm/internal/asm/testdata/amd64enc.s index 63ba7cafea1..63fdcac27db 100644 --- a/src/cmd/asm/internal/asm/testdata/amd64enc.s +++ b/src/cmd/asm/internal/asm/testdata/amd64enc.s @@ -1878,39 +1878,39 @@ TEXT asmtest(SB),7,$0 FXTRACT // d9f4 FYL2X // d9f1 FYL2XP1 // d9f9 - //TODO: HADDPD (BX), X2 // 660f7c13 - //TODO: HADDPD (R11), X2 // 66410f7c13 - //TODO: HADDPD X2, X2 // 660f7cd2 - //TODO: HADDPD X11, X2 // 66410f7cd3 - //TODO: HADDPD (BX), X11 // 66440f7c1b - //TODO: HADDPD (R11), X11 // 66450f7c1b - //TODO: HADDPD X2, X11 // 66440f7cda - //TODO: HADDPD X11, X11 // 66450f7cdb - //TODO: HADDPS (BX), X2 // f20f7c13 - //TODO: HADDPS (R11), X2 // f2410f7c13 - //TODO: HADDPS X2, X2 // f20f7cd2 - //TODO: HADDPS X11, X2 // f2410f7cd3 - //TODO: HADDPS (BX), X11 // f2440f7c1b - //TODO: HADDPS (R11), X11 // f2450f7c1b - //TODO: HADDPS X2, X11 // f2440f7cda - //TODO: HADDPS X11, X11 // f2450f7cdb + 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 - //TODO: HSUBPD (BX), X2 // 660f7d13 - //TODO: HSUBPD (R11), X2 // 66410f7d13 - //TODO: HSUBPD X2, X2 // 660f7dd2 - //TODO: HSUBPD X11, X2 // 66410f7dd3 - //TODO: HSUBPD (BX), X11 // 66440f7d1b - //TODO: HSUBPD (R11), X11 // 66450f7d1b - //TODO: HSUBPD X2, X11 // 66440f7dda - //TODO: HSUBPD X11, X11 // 66450f7ddb - //TODO: HSUBPS (BX), X2 // f20f7d13 - //TODO: HSUBPS (R11), X2 // f2410f7d13 - //TODO: HSUBPS X2, X2 // f20f7dd2 - //TODO: HSUBPS X11, X2 // f2410f7dd3 - //TODO: HSUBPS (BX), X11 // f2440f7d1b - //TODO: HSUBPS (R11), X11 // f2450f7d1b - //TODO: HSUBPS X2, X11 // f2440f7dda - //TODO: HSUBPS X11, X11 // f2450f7ddb + 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 diff --git a/src/cmd/internal/obj/x86/a.out.go b/src/cmd/internal/obj/x86/a.out.go index efce9867d52..12eaa90bf6f 100644 --- a/src/cmd/internal/obj/x86/a.out.go +++ b/src/cmd/internal/obj/x86/a.out.go @@ -89,7 +89,11 @@ const ( ADIVL ADIVW AENTER + AHADDPD + AHADDPS AHLT + AHSUBPD + AHSUBPS AIDIVB AIDIVL AIDIVW diff --git a/src/cmd/internal/obj/x86/anames.go b/src/cmd/internal/obj/x86/anames.go index b1c3f00f7c9..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", diff --git a/src/cmd/internal/obj/x86/asm6.go b/src/cmd/internal/obj/x86/asm6.go index fdc25faf98a..4ed1d8790bc 100644 --- a/src/cmd/internal/obj/x86/asm6.go +++ b/src/cmd/internal/obj/x86/asm6.go @@ -1171,6 +1171,10 @@ 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}}, From 830143fa3dd344a72d5c00643983ab62abb88a72 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 26 Jan 2016 05:28:20 -0800 Subject: [PATCH 052/128] time: fix comment about use of Location.cacheEnd Fixes #14099. Change-Id: I122e918bdc55fb185f4a4a797489b160219542d2 Reviewed-on: https://go-review.googlesource.com/18943 Run-TryBot: Ian Lance Taylor Reviewed-by: Russ Cox --- src/time/zoneinfo.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 From 980364b7a2425657a5c66dcad4e52f6cd3723a77 Mon Sep 17 00:00:00 2001 From: Kevin Kirsche Date: Fri, 22 Jan 2016 11:04:07 -0500 Subject: [PATCH 053/128] crypto/cipher: Add AES-GCM encryption and decryption example Add example of how to use the aes package to implement AES encryption and decryption within an application. Per feedback, use more secure AES-GCM implementation as an example in crypto/cipher instead of AES directly. Change-Id: I84453ebb18e0bc79344a24171a031ec0d7ccec2e Reviewed-on: https://go-review.googlesource.com/18803 Reviewed-by: Brad Fitzpatrick Run-TryBot: Brad Fitzpatrick --- src/crypto/cipher/example_test.go | 52 +++++++++++++++++++++++++++++++ 1 file changed, 52 insertions(+) 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") From 038b8139433054c70f17494f4cd96dd4f3ddd696 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Sat, 23 Jan 2016 23:31:23 -0500 Subject: [PATCH 054/128] net/url: allow spaces in IPv6 zone identifier for Windows Windows: putting spaces where they don't belong since Windows NT 3.1. Fixes #14002. Change-Id: I48ba8a7bfe3f27f83c8aa8355a8d355933d6c5df Reviewed-on: https://go-review.googlesource.com/18855 Reviewed-by: Brad Fitzpatrick --- src/net/url/url.go | 3 ++- src/net/url/url_test.go | 11 +++++++++++ 2 files changed, 13 insertions(+), 1 deletion(-) 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 From b4c9d01d81d90a78a4330d3e3567bc5533e8c659 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Sat, 23 Jan 2016 23:43:08 -0500 Subject: [PATCH 055/128] crypto: document that Signer.Sign does not hash Fixes #13938. Change-Id: I0b4842b8bc22dc79323d6894c123cde638f52d3f Reviewed-on: https://go-review.googlesource.com/18856 Reviewed-by: Adam Langley --- src/crypto/crypto.go | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) 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. From c2b40809c136c341716287a30f1a619b2921f075 Mon Sep 17 00:00:00 2001 From: Mikio Hara Date: Tue, 26 Jan 2016 16:29:47 +0900 Subject: [PATCH 056/128] net/http: fix nit in test Change-Id: I8c647e709d93a76636e04375609fceadf3754aa1 Reviewed-on: https://go-review.googlesource.com/18954 Reviewed-by: Ian Lance Taylor --- src/net/http/response_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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) } From 1aab7b9626b8bc735d7340c1eb47d8d46560290f Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Mon, 25 Jan 2016 11:44:02 -0800 Subject: [PATCH 057/128] cmd/link: add -extar option to set ar program for c-archive People who want to use -buildmode=c-archive in unusual cross-compilation setups will need something like this. It could also be done via (yet another) environment variable but I use -extar by analogy with the existing -extld. Change-Id: I354cfabc4c470603affd13cd946997b3a24c0e6c Reviewed-on: https://go-review.googlesource.com/18913 Reviewed-by: Russ Cox Run-TryBot: Ian Lance Taylor TryBot-Result: Gobot Gobot --- misc/cgo/testcarchive/test.bash | 18 ++++++++++++++++++ src/cmd/link/doc.go | 3 +++ src/cmd/link/internal/ld/lib.go | 7 ++++++- src/cmd/link/internal/ld/pobj.go | 1 + 4 files changed, 28 insertions(+), 1 deletion(-) 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/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/ld/lib.go b/src/cmd/link/internal/ld/lib.go index a23a437e3d0..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 @@ -1015,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()...) 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']) From bdc3db0b0c4044ed396238fb7e01574988a14aad Mon Sep 17 00:00:00 2001 From: Alberto Donizetti Date: Tue, 19 Jan 2016 20:47:59 +0100 Subject: [PATCH 058/128] doc: update install from source instructions for go1.5.3 Fixes #14020 Change-Id: I454c2613912a7efcb464c6e6f3ac2e0ec89fb719 Reviewed-on: https://go-review.googlesource.com/18750 Reviewed-by: Andrew Gerrand Reviewed-by: Chris Broadfoot Reviewed-by: Russ Cox --- doc/install-source.html | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/install-source.html b/doc/install-source.html index 60931ada5da..7c1194a22c6 100644 --- a/doc/install-source.html +++ b/doc/install-source.html @@ -184,7 +184,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 +363,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.

    From 2c12b81739ec2cb85073e125748fcbf5d2febb2c Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Tue, 26 Jan 2016 18:55:35 +0000 Subject: [PATCH 059/128] net/http: document TimeFormat more Fixes #14103 Change-Id: I89963643eccc902b809e04b7a14153acb0d242e1 Reviewed-on: https://go-review.googlesource.com/18933 Reviewed-by: Ian Lance Taylor --- src/net/http/server.go | 10 ++++++---- 1 file changed, 6 insertions(+), 4 deletions(-) diff --git a/src/net/http/server.go b/src/net/http/server.go index 2ec106927b9..004a1f92fc4 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)) From aff6aa0a21baa332bb94c34795520008c8db9198 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Tue, 26 Jan 2016 20:33:21 +0000 Subject: [PATCH 060/128] net/http: quiet http2 log spam Updates x/net/http2 to git rev eb066e3 for https://golang.org/cl/18932 Fixes #13925 Fixes #14061 Change-Id: I73f8c09232877404362358240b7b369bb9c76a12 Reviewed-on: https://go-review.googlesource.com/18934 Reviewed-by: Brad Fitzpatrick Run-TryBot: Brad Fitzpatrick TryBot-Result: Gobot Gobot --- src/net/http/h2_bundle.go | 47 +++++++++++++++++++++++++++++++++++---- 1 file changed, 43 insertions(+), 4 deletions(-) diff --git a/src/net/http/h2_bundle.go b/src/net/http/h2_bundle.go index 21106419559..e7236299e22 100644 --- a/src/net/http/h2_bundle.go +++ b/src/net/http/h2_bundle.go @@ -32,6 +32,7 @@ import ( "net/textproto" "net/url" "os" + "reflect" "runtime" "sort" "strconv" @@ -2850,12 +2851,50 @@ func (sc *http2serverConn) logf(format string, args ...interface{}) { } } +var http2uintptrType = reflect.TypeOf(uintptr(0)) + +// 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 { @@ -3372,7 +3411,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 @@ -3401,7 +3440,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) } From 7037c15e19582cb192cb1edfa7e2c1bf46746ee5 Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Fri, 15 Jan 2016 14:23:43 -0500 Subject: [PATCH 061/128] runtime/pprof: retry failed tests with longer duration Currently we run profiling tests for around 200ms in short mode. However, even on platforms with good profiling, these tests are inherently flaky, especially on loaded systems like the builders. To mitigate this, modify the profiling test harness so that if a test fails in a way that could indicate there just weren't enough samples, it retries with a longer duration. This requires some adjustment to the profile checker to distinguish "fatal" and "retryable" errors. In particular, we no longer consider it a fatal error to get a profile with zero samples (which we previously treated as a parse error). We replace this with a retryable check that the total number of samples is reasonable. Fixes #13943. Fixes #13871. Fixes #13223. Change-Id: I9a08664a7e1734c5334b1f3792a56184fe314c4d Reviewed-on: https://go-review.googlesource.com/18683 Reviewed-by: Russ Cox Run-TryBot: Austin Clements TryBot-Result: Gobot Gobot --- src/runtime/pprof/pprof_test.go | 124 +++++++++++++++++++------------- 1 file changed, 75 insertions(+), 49 deletions(-) diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go index c241b54ae77..621d21d3272 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,8 +92,8 @@ 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) @@ -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/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() +} + +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 { @@ -365,13 +395,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) From d3e61747da7f27c5dd67a514ff533be54df95b85 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Tue, 26 Jan 2016 22:56:08 +0000 Subject: [PATCH 062/128] doc: mention the need for a C compiler for cgo support Fixes #13954 Change-Id: I4c01e9bb3fb08e8b9fa14d4c59b7ea824ba3f0c9 Reviewed-on: https://go-review.googlesource.com/18937 Reviewed-by: Ian Lance Taylor Reviewed-by: Rob Pike --- doc/install-source.html | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/doc/install-source.html b/doc/install-source.html index 7c1194a22c6..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

    From 843745240430e6b6c0a94b31ca3ddc2cd77b3b06 Mon Sep 17 00:00:00 2001 From: Adam Langley Date: Sun, 10 Jan 2016 18:30:27 -0800 Subject: [PATCH 063/128] crypto/rsa: expand on documentation and add some examples. In some cases the documentation for functions in this package was lacking from the beginning and, in order cases, the documentation didn't keep pace as the package grew. This change somewhat addresses that. Updates #13711. Change-Id: I25b2bb1fcd4658c5417671e23cf8e644d08cb9ab Reviewed-on: https://go-review.googlesource.com/18486 Reviewed-by: Rob Pike Reviewed-by: Andrew Gerrand Reviewed-by: Brad Fitzpatrick Run-TryBot: Brad Fitzpatrick --- src/crypto/rsa/example_test.go | 169 +++++++++++++++++++++++++++++++++ src/crypto/rsa/pkcs1v15.go | 23 +++++ src/crypto/rsa/rsa.go | 41 +++++++- 3 files changed, 232 insertions(+), 1 deletion(-) create mode 100644 src/crypto/rsa/example_test.go 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 From 1d901f55bd9d6ee12bc4692cd60a6a2311366799 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 26 Jan 2016 11:50:51 -0500 Subject: [PATCH 064/128] cmd/compile: remove -h spam This debugging print crept into an earlier CL of mine. Change-Id: If6e8609e69a60aec50c06889c2d98a8b8a4bd02b Reviewed-on: https://go-review.googlesource.com/18971 Run-TryBot: Russ Cox Reviewed-by: Ian Lance Taylor --- src/cmd/compile/internal/gc/gen.go | 3 --- 1 file changed, 3 deletions(-) diff --git a/src/cmd/compile/internal/gc/gen.go b/src/cmd/compile/internal/gc/gen.go index 377aee8a1cf..836834f8bd7 100644 --- a/src/cmd/compile/internal/gc/gen.go +++ b/src/cmd/compile/internal/gc/gen.go @@ -605,9 +605,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 From c736280e2250a9a873423f6c4923b6f4c1caf528 Mon Sep 17 00:00:00 2001 From: Joe Tsai Date: Thu, 14 Jan 2016 00:38:48 -0800 Subject: [PATCH 065/128] archive/zip: clarify expectations of RegisterCompressor and RegisterDecompressor Clarify that Compressor and Decompressor callbacks must support being invoked concurrently, but that the writer or reader returned need not be. Updates #8359 Change-Id: Ia407b581dd124185f165c25f5701018a8ce4357a Reviewed-on: https://go-review.googlesource.com/18627 Reviewed-by: Brad Fitzpatrick Run-TryBot: Brad Fitzpatrick --- src/archive/zip/example_test.go | 17 +++-------------- src/archive/zip/reader.go | 2 -- src/archive/zip/register.go | 25 +++++++++++++++---------- 3 files changed, 18 insertions(+), 26 deletions(-) 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..84a9d41888d 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) 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. From 73d590b4bd3e4dbf48613a09db938bf2fe03a1aa Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 26 Jan 2016 15:26:09 -0500 Subject: [PATCH 066/128] cmd/internal/obj/arm64: adjust literal pool flush for span-dependent jump enlargement The current code delays the literal pool until the very last moment, but based on the assumption that span-dependent jumps are as short as possible. If they need to be enlarged in a later round, that very last moment may be too late. Flush a little early to prevent that. Fixes #13579. Change-Id: I759b5db5c43a977bf2b940872870cbbc436ad141 Reviewed-on: https://go-review.googlesource.com/18972 Reviewed-by: Ian Lance Taylor Reviewed-by: Dave Cheney Run-TryBot: Russ Cox --- src/cmd/internal/obj/arm64/asm7.go | 15 +++++++++++---- 1 file changed, 11 insertions(+), 4 deletions(-) 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") } } From eb3b1830b01fca572fcdd9c95aeb8090e6c09497 Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Tue, 19 Jan 2016 22:45:37 -0500 Subject: [PATCH 067/128] runtime: attach mark workers to P after they park Currently mark workers attach to their designated Ps before parking, either during initialization or after performing a phase transition. However, in both of these cases, it's possible that the mark worker is running on a different P than the one it attaches to. This is a problem, because as soon as the worker attaches to a P, that P's scheduler can execute the worker. If the worker hasn't yet parked on the P it's actually running on, this means the worker G will be running in two places at once. The most visible consequence of this is that once the first instance of the worker does park, it will clear g.m and the second instance will crash shortly when it tries to use g.m. Fix this by moving the attach to the gopark callback. At this point, the G is genuinely stopped and the callback is running on the system stack, so it's safe for another P's scheduler to pick up the worker G. Fixes #13363. Fixes #13978. Change-Id: If2f7c4a4174f9511f6227e14a27c56fb842d1cc8 Reviewed-on: https://go-review.googlesource.com/18761 Reviewed-by: Rick Hudson Reviewed-by: Russ Cox Run-TryBot: Austin Clements --- src/runtime/mgc.go | 89 ++++++++++++++++++++++++++++----------------- src/runtime/proc.go | 2 + 2 files changed, 58 insertions(+), 33 deletions(-) diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go index 92b811830c3..24b8f95d158 100644 --- a/src/runtime/mgc.go +++ b/src/runtime/mgc.go @@ -1349,15 +1349,22 @@ func gcBgMarkPrepare() { work.nwait = ^uint32(0) } -func gcBgMarkWorker(p *p) { - // Register this G as the background mark worker for p. +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 + + // casgp is casp for *g's. casgp := func(gpp **g, old, new *g) bool { return casp((*unsafe.Pointer)(unsafe.Pointer(gpp)), unsafe.Pointer(old), unsafe.Pointer(new)) } 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 +1372,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 !casgp(&p.gcBgMarkWorker, nil, 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 != 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 +1430,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 +1446,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 +1466,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 +1478,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 = 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/proc.go b/src/runtime/proc.go index a7e94a9c1d4..680c5faedd8 100644 --- a/src/runtime/proc.go +++ b/src/runtime/proc.go @@ -3212,6 +3212,8 @@ func procresize(nprocs int32) *p { traceGoUnpark(p.gcBgMarkWorker, 0) } globrunqput(p.gcBgMarkWorker) + // This assignment doesn't race because the + // world is stopped. p.gcBgMarkWorker = nil } for i := range p.sudogbuf { From 08594ac7c7e123d4aa46f60690da0a7e4034f4e9 Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Tue, 26 Jan 2016 17:26:55 -0500 Subject: [PATCH 068/128] runtime: acquire stack lock in traceEvent traceEvent records system call events after a G has already entered _Gsyscall, which means the garbage collector could be installing stack barriers in the G's stack during the traceEvent. If traceEvent attempts to capture the user stack during this, it may observe a inconsistent stack barriers and panic. Fix this by acquiring the stack lock around the stack walk in traceEvent. Fixes #14101. Change-Id: I15f0ab0c70c04c6e182221f65a6f761c5a896459 Reviewed-on: https://go-review.googlesource.com/18973 Run-TryBot: Austin Clements TryBot-Result: Gobot Gobot Reviewed-by: Russ Cox --- src/runtime/trace.go | 7 ++++++- 1 file changed, 6 insertions(+), 1 deletion(-) 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 From 09940b92a08203aa3d2baa90fc29b80ccfcb32c5 Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Tue, 26 Jan 2016 14:44:58 -0500 Subject: [PATCH 069/128] runtime: make p.gcBgMarkWorker a guintptr Currently p.gcBgMarkWorker is a *g. Change it to a guintptr. This eliminates a write barrier during the subtle mark worker parking dance (which isn't known to be causing problems, but may). Change-Id: Ibf12c05ac910820448059e69a68e5b882c993ed8 Reviewed-on: https://go-review.googlesource.com/18970 Run-TryBot: Austin Clements Reviewed-by: Rick Hudson Reviewed-by: Russ Cox --- src/runtime/mgc.go | 17 ++++++----------- src/runtime/proc.go | 14 +++++++------- src/runtime/runtime2.go | 2 +- 3 files changed, 14 insertions(+), 19 deletions(-) diff --git a/src/runtime/mgc.go b/src/runtime/mgc.go index 24b8f95d158..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) @@ -1356,11 +1356,6 @@ func gcBgMarkWorker(_p_ *p) { } var park parkInfo - // casgp is casp for *g's. - casgp := func(gpp **g, old, new *g) bool { - return casp((*unsafe.Pointer)(unsafe.Pointer(gpp)), unsafe.Pointer(old), unsafe.Pointer(new)) - } - gp := getg() park.m = acquirem() park.attach = _p_ @@ -1397,7 +1392,7 @@ func gcBgMarkWorker(_p_ *p) { // cas the worker because we may be // racing with a new worker starting // on this P. - if !casgp(&p.gcBgMarkWorker, nil, g) { + if !p.gcBgMarkWorker.cas(0, guintptr(unsafe.Pointer(g))) { // The P got a new worker. // Exit this worker. return false @@ -1409,7 +1404,7 @@ func gcBgMarkWorker(_p_ *p) { // Loop until the P dies and disassociates this // worker (the P may later be reused, in which case // it will get a new worker) or we failed to associate. - if _p_.gcBgMarkWorker != gp { + if _p_.gcBgMarkWorker.ptr() != gp { break } @@ -1478,7 +1473,7 @@ func gcBgMarkWorker(_p_ *p) { // as the worker for this P so // findRunnableGCWorker doesn't try to // schedule it. - _p_.gcBgMarkWorker = nil + _p_.gcBgMarkWorker.set(nil) releasem(park.m) gcMarkDone() diff --git a/src/runtime/proc.go b/src/runtime/proc.go index 680c5faedd8..2bc3c920dc6 100644 --- a/src/runtime/proc.go +++ b/src/runtime/proc.go @@ -1867,9 +1867,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,15 +3206,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) + globrunqput(gp) // This assignment doesn't race because the // world is stopped. - p.gcBgMarkWorker = nil + p.gcBgMarkWorker.set(nil) } for i := range p.sudogbuf { p.sudogbuf[i] = nil 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 From 9202e9e1b81d1c6d07b516eae2d1da28951c7a76 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Wed, 27 Jan 2016 00:09:50 +0000 Subject: [PATCH 070/128] runtime: add more debug info to flaky TestNumGoroutine This has been flaking on the new OpenBSD 5.8 builders lately: https://storage.googleapis.com/go-build-log/808270e7/openbsd-amd64-gce58_61ce2663.log (as one example) Add more debug info when it fails. Updates #14107 Change-Id: Ie30bc0c703d2e9ee993d1e232ffc5f2d17e65c97 Reviewed-on: https://go-review.googlesource.com/18938 Run-TryBot: Brad Fitzpatrick TryBot-Result: Gobot Gobot Reviewed-by: Matthew Dempsky --- src/runtime/proc_test.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/runtime/proc_test.go b/src/runtime/proc_test.go index f3e90bcbd76..34d90a1c9bf 100644 --- a/src/runtime/proc_test.go +++ b/src/runtime/proc_test.go @@ -350,7 +350,7 @@ func TestNumGoroutine(t *testing.T) { n := runtime.NumGoroutine() if nstk := strings.Count(string(buf), "goroutine "); n != nstk { - t.Fatalf("NumGoroutine=%d, but found %d goroutines in stack dump", n, nstk) + t.Fatalf("NumGoroutine=%d, but found %d goroutines in stack dump: %s", n, nstk, buf) } } From 4ec2fd3e6ac4f869d39348bf48016687b731d910 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 26 Jan 2016 20:03:32 -0500 Subject: [PATCH 071/128] cmd/go: disable broken test for code.google.com For Go 1.7 we can remove all the code.google.com code (except maybe the shutdown warning). See #10193. Change-Id: I4b8182eb66494f0bf373b40ca5da6ae4738342be Reviewed-on: https://go-review.googlesource.com/18974 Reviewed-by: Brad Fitzpatrick Run-TryBot: Russ Cox TryBot-Result: Gobot Gobot --- src/cmd/go/go_test.go | 1 + src/cmd/go/vcs_test.go | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go index 50c7521831e..dc6fd469aff 100644 --- a/src/cmd/go/go_test.go +++ b/src/cmd/go/go_test.go @@ -2255,6 +2255,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/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, From 313fd1cb1343e46b563b6b8acfef7e58604b5b8f Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 26 Jan 2016 22:58:59 -0500 Subject: [PATCH 072/128] runtime: fix crash in GoroutineProfile It was just completely broken if you gave it the number of records it asked for. Make it impossible for that particular inconsistency to happen again. Also make it exclude system goroutines, to match both NumGoroutine and Stack. Fixes #14046. Change-Id: Ic238c6b89934ba7b47cccd3440dd347ed11e4c3d Reviewed-on: https://go-review.googlesource.com/18976 Run-TryBot: Russ Cox Reviewed-by: Austin Clements TryBot-Result: Gobot Gobot --- src/runtime/mprof.go | 50 +++++++++++++++++++++++-------------- src/runtime/runtime_test.go | 12 +++++++++ 2 files changed, 43 insertions(+), 19 deletions(-) diff --git a/src/runtime/mprof.go b/src/runtime/mprof.go index eb7231aec22..e45bc7a7701 100644 --- a/src/runtime/mprof.go +++ b/src/runtime/mprof.go @@ -522,34 +522,46 @@ 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) { saveg(^uintptr(0), ^uintptr(0), gp1, &r[0]) r = r[1:] } } - - startTheWorld() } + startTheWorld() + return n, ok } diff --git a/src/runtime/runtime_test.go b/src/runtime/runtime_test.go index 664c1180c42..581f52bcb08 100644 --- a/src/runtime/runtime_test.go +++ b/src/runtime/runtime_test.go @@ -308,3 +308,15 @@ func TestAppendSliceGrowth(t *testing.T) { } } } + +func TestGoroutineProfileTrivial(t *testing.T) { + 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 { + t.Fatalf("GoroutineProfile(%d) = %d, %v, want %d, true", n1, n2, ok, n1) + } +} From d9fdbf48207e24c1d0d771250f2cc811ef97adff Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 26 Jan 2016 23:00:41 -0500 Subject: [PATCH 073/128] runtime: guard against array out of bounds in GoroutineProfile The previous CL is the real fix. This one is just insurance. Fixes #14046 again. Change-Id: I553349504bb1789e4b66c888dbe4034568918ad6 Reviewed-on: https://go-review.googlesource.com/18977 Reviewed-by: Austin Clements --- src/runtime/mprof.go | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/runtime/mprof.go b/src/runtime/mprof.go index e45bc7a7701..fc73bbfbe15 100644 --- a/src/runtime/mprof.go +++ b/src/runtime/mprof.go @@ -554,6 +554,11 @@ func GoroutineProfile(p []StackRecord) (n int, ok bool) { // 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:] } From 26397f1383ff02770a62160891e9de349aa1fb92 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 26 Jan 2016 22:13:01 -0500 Subject: [PATCH 074/128] runtime: fix upper bound on out-of-memory print It's possible for arena_start+MaxArena32 to wrap. We do the right thing in the bounds check but not in the print. For #13992 (to fix the print there, not the bug). Change-Id: I4df845d0c03f0f35461b128e4f6765d3ccb71c6d Reviewed-on: https://go-review.googlesource.com/18975 Run-TryBot: Russ Cox Reviewed-by: Austin Clements --- src/runtime/malloc.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) 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 } From 867bef93b9a60ef07f068bc8d2d4398b76331e3c Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Tue, 26 Jan 2016 20:58:00 +0000 Subject: [PATCH 075/128] database/sql: implement Scan of time.Time, document, clarify Scan error text Fixes #9157 Change-Id: Iadf305a172a0ec53ae91e1b2db3f3351691a48ff Reviewed-on: https://go-review.googlesource.com/18935 Reviewed-by: Russ Cox Reviewed-by: Andrew Gerrand --- src/database/sql/convert.go | 31 ++++++++++++++-- src/database/sql/convert_test.go | 23 ++++++++++-- src/database/sql/sql.go | 63 ++++++++++++++++++++++++++------ 3 files changed, 98 insertions(+), 19 deletions(-) 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 { From f49a757ad0d8f5987953684ea20153c713f7d9b9 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 26 Jan 2016 17:23:33 -0800 Subject: [PATCH 076/128] unsafe: clarify that Alignof returns required alignment Also document the special behavior of Alignof(s.f), and mention the correspondence between Alignof and reflect.Type.{Align,FieldAlign}. Change-Id: I6f81047a04c86887f1b1164473225616cae45a26 Reviewed-on: https://go-review.googlesource.com/18949 Run-TryBot: Ian Lance Taylor Reviewed-by: Russ Cox --- src/unsafe/unsafe.go | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/src/unsafe/unsafe.go b/src/unsafe/unsafe.go index 34ca77965b2..3c8cd34ae20 100644 --- a/src/unsafe/unsafe.go +++ b/src/unsafe/unsafe.go @@ -183,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 s has a 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 From bd7e084d7d4eb88829026b5bdaf0915d5a389048 Mon Sep 17 00:00:00 2001 From: Richard Miller Date: Wed, 27 Jan 2016 11:49:58 +0000 Subject: [PATCH 077/128] cmd/link: correct byte ordering in plan9_arm object header Fields in Plan 9 object headers are big-endian, on all architectures. Change-Id: If95ad29750b776338178d660646568bf26a4abda Reviewed-on: https://go-review.googlesource.com/18964 Reviewed-by: Russ Cox --- src/cmd/link/internal/arm/asm.go | 16 ++++++++-------- src/runtime/asm_arm.s | 5 +++++ 2 files changed, 13 insertions(+), 8 deletions(-) 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/runtime/asm_arm.s b/src/runtime/asm_arm.s index 09fbc952e09..53128e7eb1e 100644 --- a/src/runtime/asm_arm.s +++ b/src/runtime/asm_arm.s @@ -81,12 +81,17 @@ DATA runtime·mainPC+0(SB)/4,$runtime·main(SB) GLOBL runtime·mainPC(SB),RODATA,$4 TEXT runtime·breakpoint(SB),NOSPLIT,$0-0 + BL runtime·emptyfunc(SB) // force R14 save for traceback // gdb won't skip this breakpoint instruction automatically, // 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 From 158f19b259da623c1afcfaa1812a71601aa2d2a8 Mon Sep 17 00:00:00 2001 From: Richard Miller Date: Wed, 27 Jan 2016 11:27:50 +0000 Subject: [PATCH 078/128] cmd/go: recognise plan9_arm object files Add magic word for Plan 9 ARM object header to objectMagic table. Change-Id: I21eb8845a2ee2e8cdddc0849eedf43481aee9cde Reviewed-on: https://go-review.googlesource.com/18963 Reviewed-by: Russ Cox --- src/cmd/go/build.go | 1 + 1 file changed, 1 insertion(+) diff --git a/src/cmd/go/build.go b/src/cmd/go/build.go index e127524ceb3..12867004aad 100644 --- a/src/cmd/go/build.go +++ b/src/cmd/go/build.go @@ -1835,6 +1835,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 { From 9b67a5de79af56541c48c95c6d7ddc8630e1d0dc Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Tue, 26 Jan 2016 19:57:19 +0000 Subject: [PATCH 079/128] net/http: add protections against misuse of ServeFile Martin Lenord pointed out that bad patterns have emerged in online examples of how to use ServeFile, where people pass r.URL.Path[1:] to ServeFile. This is unsafe. Document that it's unsafe, and add some protections. Fixes #14110 Change-Id: Ifeaa15534b2b3e46d3a8137be66748afa8fcd634 Reviewed-on: https://go-review.googlesource.com/18939 Reviewed-by: Andrew Gerrand Reviewed-by: Russ Cox Run-TryBot: Brad Fitzpatrick --- src/net/http/fs.go | 29 +++++++++++++++++++++++++++++ src/net/http/fs_test.go | 31 +++++++++++++++++++++++++++++++ 2 files changed, 60 insertions(+) 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 }{ From 08396f7825ee1f4349abfd389ff26a451d88f164 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Wed, 27 Jan 2016 06:42:10 -0800 Subject: [PATCH 080/128] doc: mention signal changes for c-archive/c-shared Change-Id: Ibba7fccba9617612e026bd0a208eb12918de465a Reviewed-on: https://go-review.googlesource.com/18985 Reviewed-by: Russ Cox --- doc/go1.6.html | 13 +++++++++++++ 1 file changed, 13 insertions(+) diff --git a/doc/go1.6.html b/doc/go1.6.html index 5e5149fa101..cd1515224d6 100644 --- a/doc/go1.6.html +++ b/doc/go1.6.html @@ -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

    From 1023d63f7f0ee31f5810e3e5598227c85442a1e2 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Wed, 27 Jan 2016 09:23:48 -0800 Subject: [PATCH 081/128] unsafe: clarify wording in recent Alignof changes Change-Id: I595379d2f02b0a43735f0375758e4997ce3b64a7 Reviewed-on: https://go-review.googlesource.com/18986 Run-TryBot: Ian Lance Taylor Reviewed-by: Brad Fitzpatrick TryBot-Result: Gobot Gobot --- src/unsafe/unsafe.go | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/src/unsafe/unsafe.go b/src/unsafe/unsafe.go index 3c8cd34ae20..33b31142192 100644 --- a/src/unsafe/unsafe.go +++ b/src/unsafe/unsafe.go @@ -187,8 +187,8 @@ func Offsetof(x ArbitraryType) uintptr // 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 always zero mod m. // It is the same as the value returned by reflect.TypeOf(x).Align(). -// As a special case, if s has a 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(). +// 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 From 4223675913762a12cd23871fbd003d8a68cb49a1 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Wed, 27 Jan 2016 10:05:18 -0500 Subject: [PATCH 082/128] cmd/go: refine definition of 'standard' import paths to include vendored code The vendored copy of golang.org/x/net/http/hpack was being treated as not standard, which in turn was making it not subject to the mtime exception for rebuilding the standard library in a release, which in turn was making net/http look out of date. One fix and three tests: - Fix the definition of standard. - Test that everything in $GOROOT/src/ is standard during 'go test cmd/go'. (In general there can be non-standard things in $GOROOT/src/, but this test implies that you can do that or you can run 'go test cmd/go', but not both. That's fine.) - Test that 'go list std cmd' shows our vendored code. - Enforce that no standard package can depend on a non-standard one. Also fix a few error printing nits. Fixes #13713. Change-Id: I1f943f1c354174c199e9b52075c11ee44198e81b Reviewed-on: https://go-review.googlesource.com/18978 Reviewed-by: Brad Fitzpatrick Reviewed-by: Ian Lance Taylor Run-TryBot: Russ Cox --- src/cmd/go/go_test.go | 37 ++++++++++++++++++++++++++++++++++--- src/cmd/go/main.go | 5 ++--- src/cmd/go/pkg.go | 28 ++++++++++++++++++++++++++-- src/cmd/go/run.go | 14 ++++++++++++-- 4 files changed, 74 insertions(+), 10 deletions(-) diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go index dc6fd469aff..a901ca8666c 100644 --- a/src/cmd/go/go_test.go +++ b/src/cmd/go/go_test.go @@ -666,10 +666,41 @@ 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") +} + +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) { diff --git a/src/cmd/go/main.go b/src/cmd/go/main.go index c6d77f7884f..c8697ffe98c 100644 --- a/src/cmd/go/main.go +++ b/src/cmd/go/main.go @@ -588,10 +588,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..112f820d802 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() @@ -933,6 +946,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) { 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" { From 01ca4da0efc6036bf22a99593a583c1efc2750c5 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Wed, 27 Jan 2016 11:02:45 -0500 Subject: [PATCH 083/128] doc: mention ServeFile change in go1.6.html Also fix a few bad links. Change-Id: If04cdd312db24a827a3c958a9974c50ab148656c Reviewed-on: https://go-review.googlesource.com/18979 Reviewed-by: Brad Fitzpatrick --- doc/go1.6.html | 30 +++++++++++++++++++----------- 1 file changed, 19 insertions(+), 11 deletions(-) diff --git a/doc/go1.6.html b/doc/go1.6.html index cd1515224d6..46a8f65db3f 100644 --- a/doc/go1.6.html +++ b/doc/go1.6.html @@ -654,7 +654,7 @@ and add NYCbCrA and -NYCbCrA +NYCbCrA types, to support Y'CbCr images with non-premultiplied alpha.

    • @@ -738,12 +738,20 @@ 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 +Transport.ExpectContinueTimeout). +Fourth, there are five new error codes from RFC 6585: StatusPreconditionRequired (428), StatusTooManyRequests (429), @@ -751,10 +759,10 @@ Third, there are StatusUnavailableForLegalReasons (451)), and StatusNetworkAuthenticationRequired (511). -Fourth, the implementation and documentation of -CloseNotifier +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 @@ -764,17 +772,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. From d326a9641994eccdac1c95901762af45ec801bf1 Mon Sep 17 00:00:00 2001 From: Richard Miller Date: Wed, 27 Jan 2016 19:10:11 +0000 Subject: [PATCH 084/128] runtime: remove redundant empty function call from Breakpoint on arm CL 18964 included an extra patch (sorry, my first experience of git-codereview) which defined the conventional breakpoint instruction used by Plan 9 on arm, but also introduced a benign but unneeded call to runtime.emptyfunc. This CL removes the redundant call again. This completes the series of CLs which add support for Plan 9 on arm. Change-Id: Id293cfd40557c9d79b4b6cb164ed7ed49295b178 Reviewed-on: https://go-review.googlesource.com/19010 Reviewed-by: Brad Fitzpatrick --- src/runtime/asm_arm.s | 1 - 1 file changed, 1 deletion(-) diff --git a/src/runtime/asm_arm.s b/src/runtime/asm_arm.s index 53128e7eb1e..07894a3a722 100644 --- a/src/runtime/asm_arm.s +++ b/src/runtime/asm_arm.s @@ -81,7 +81,6 @@ DATA runtime·mainPC+0(SB)/4,$runtime·main(SB) GLOBL runtime·mainPC(SB),RODATA,$4 TEXT runtime·breakpoint(SB),NOSPLIT,$0-0 - BL runtime·emptyfunc(SB) // force R14 save for traceback // gdb won't skip this breakpoint instruction automatically, // so you must manually "set $pc+=4" to skip it and continue. #ifdef GOOS_nacl From 572f7660a774ebd8552408a6058b36cc90f6f563 Mon Sep 17 00:00:00 2001 From: Dmitry Vyukov Date: Wed, 27 Jan 2016 19:22:28 +0100 Subject: [PATCH 085/128] runtime/race: run tests with GOMAXPROCS=1 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. This reduces flakes on RaceAsFunc3 test from 60/3000 to 1/3000. Fixes #14086 Fixes #14079 Fixes #14035 Change-Id: Ibaec6b2b21e27b62563bffbb28473a854722cf41 Reviewed-on: https://go-review.googlesource.com/18968 Reviewed-by: Austin Clements Run-TryBot: Austin Clements Reviewed-by: Russ Cox TryBot-Result: Gobot Gobot --- src/runtime/race/output_test.go | 5 ++++- src/runtime/race/race_test.go | 15 ++++++++++++++- 2 files changed, 18 insertions(+), 2 deletions(-) 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() } From e3f3f940a09ee99e952be43fd3b19c969cf229d0 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Wed, 27 Jan 2016 15:58:52 -0500 Subject: [PATCH 086/128] runtime/cgo: add cgo build tag to C files This makes "CGO_ENABLED=0 go list runtime/cgo" work, which fixes the current cmd/go test failure. Change-Id: Ia55ce3ba1dbb09f618ae5f4c8547722670360f59 Reviewed-on: https://go-review.googlesource.com/19001 Run-TryBot: Russ Cox Reviewed-by: Brad Fitzpatrick --- src/runtime/cgo/gcc_darwin_amd64.c | 2 ++ src/runtime/cgo/gcc_libinit.c | 1 + src/runtime/cgo/gcc_setenv.c | 1 + src/runtime/cgo/gcc_util.c | 2 ++ 4 files changed, 6 insertions(+) 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_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_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_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 */ From b460d1d52ffe911828dee58352d3cebbe04d5f30 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Wed, 27 Jan 2016 13:18:35 -0800 Subject: [PATCH 087/128] cmd/internal/obj/x86: skip test when GOHOSTARCH is set It's causing the darwin-386 builder to fail with: --- FAIL: TestDynlink (0.07s) obj6_test.go:118: error exit status 3 output go tool: no such tool "asm" FAIL FAIL cmd/internal/obj/x86 0.073s So skip it for now. It's tested in enough other places. Change-Id: I9a98ad7b8be807005750112d892ac6c676c17dd5 Reviewed-on: https://go-review.googlesource.com/18989 Run-TryBot: Brad Fitzpatrick Reviewed-by: Russ Cox --- src/cmd/internal/obj/x86/obj6_test.go | 7 +++++++ 1 file changed, 7 insertions(+) diff --git a/src/cmd/internal/obj/x86/obj6_test.go b/src/cmd/internal/obj/x86/obj6_test.go index 4387db696d0..5fa1d3bfcff 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) From 3a21f0a9c1d3b57608eca4950b77adaf834f250c Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Wed, 27 Jan 2016 16:27:03 -0500 Subject: [PATCH 088/128] runtime/cgo: more +build cgo tags Followup to CL 19001. Change-Id: I7fa838b1ee8df53229e9dd29a231c2f9b2aa3f69 Reviewed-on: https://go-review.googlesource.com/19003 Reviewed-by: Brad Fitzpatrick --- src/runtime/cgo/gcc_android.c | 2 ++ src/runtime/cgo/gcc_android_386.c | 2 ++ src/runtime/cgo/gcc_android_amd64.c | 2 ++ src/runtime/cgo/gcc_android_arm.c | 2 ++ src/runtime/cgo/gcc_android_arm64.c | 2 ++ src/runtime/cgo/gcc_darwin_386.c | 2 ++ src/runtime/cgo/gcc_darwin_arm.c | 2 ++ src/runtime/cgo/gcc_darwin_arm64.c | 2 ++ src/runtime/cgo/gcc_dragonfly_amd64.c | 2 ++ src/runtime/cgo/gcc_fatalf.c | 2 ++ src/runtime/cgo/gcc_freebsd_386.c | 2 ++ src/runtime/cgo/gcc_freebsd_amd64.c | 2 ++ src/runtime/cgo/gcc_freebsd_arm.c | 2 ++ src/runtime/cgo/gcc_libinit_linux_ppc64x.c | 2 ++ src/runtime/cgo/gcc_libinit_openbsd.c | 2 ++ src/runtime/cgo/gcc_libinit_windows.c | 2 ++ src/runtime/cgo/gcc_linux_386.c | 2 ++ src/runtime/cgo/gcc_linux_amd64.c | 2 ++ src/runtime/cgo/gcc_linux_arm.c | 2 ++ src/runtime/cgo/gcc_linux_arm64.c | 2 ++ src/runtime/cgo/gcc_linux_ppc64x.c | 2 ++ src/runtime/cgo/gcc_mmap.c | 2 ++ src/runtime/cgo/gcc_netbsd_386.c | 2 ++ src/runtime/cgo/gcc_netbsd_amd64.c | 2 ++ src/runtime/cgo/gcc_netbsd_arm.c | 2 ++ src/runtime/cgo/gcc_openbsd_386.c | 2 ++ src/runtime/cgo/gcc_openbsd_amd64.c | 2 ++ src/runtime/cgo/gcc_signal_darwin_armx.c | 2 ++ src/runtime/cgo/gcc_signal_darwin_lldb.c | 2 ++ src/runtime/cgo/gcc_solaris_amd64.c | 2 ++ src/runtime/cgo/gcc_windows_386.c | 2 ++ src/runtime/cgo/gcc_windows_amd64.c | 2 ++ 32 files changed, 64 insertions(+) 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_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 f41b9b408a3..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 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_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 6fc7a122b4b..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 diff --git a/src/runtime/cgo/gcc_netbsd_amd64.c b/src/runtime/cgo/gcc_netbsd_amd64.c index f0ecfac575a..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 diff --git a/src/runtime/cgo/gcc_netbsd_arm.c b/src/runtime/cgo/gcc_netbsd_arm.c index 3567aaae725..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 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_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_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 From a3c1a3f40120b4cf6a5e24025a0279a8c48ea22f Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Wed, 27 Jan 2016 16:21:33 -0500 Subject: [PATCH 089/128] runtime: deflake TestNumGoroutine Fixes #14107. Change-Id: Icd9463b1a77b139c7ebc2d8732482d704ea332d0 Reviewed-on: https://go-review.googlesource.com/19002 Reviewed-by: Brad Fitzpatrick --- src/runtime/proc_test.go | 23 +++++++++++++++++++---- 1 file changed, 19 insertions(+), 4 deletions(-) diff --git a/src/runtime/proc_test.go b/src/runtime/proc_test.go index 34d90a1c9bf..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: %s", n, nstk, buf) + 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) + } } } From e7ce1ba88c7c2a8c02c48ecb341540b30d9e9159 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Wed, 27 Jan 2016 17:24:03 -0500 Subject: [PATCH 090/128] misc/cgo/test: disable sigaltstack test on darwin/386 It doesn't work there ("out of memory") and doesn't really matter. Fixes build (now that we enable cgo on the darwin/386 builder.) Change-Id: I1d91e51ecb88c54eae39ac9a76f2c0b4e45263b0 Reviewed-on: https://go-review.googlesource.com/19004 Run-TryBot: Russ Cox Reviewed-by: Brad Fitzpatrick --- misc/cgo/test/sigaltstack.go | 2 ++ 1 file changed, 2 insertions(+) diff --git a/misc/cgo/test/sigaltstack.go b/misc/cgo/test/sigaltstack.go index 178e71c9b70..b641ff60374 100644 --- a/misc/cgo/test/sigaltstack.go +++ b/misc/cgo/test/sigaltstack.go @@ -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() From e97096661ecaf1f7476c2320208d92709b72279d Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Wed, 27 Jan 2016 14:07:25 -0800 Subject: [PATCH 091/128] runtime: handle kindString in cgoCheckArg It's awkward to get a string value in cgoCheckArg, but SWIG testing revealed that it is possible. The new handling of extra files in the ptr.go test emulates what SWIG does with an exported function that returns a string. Change-Id: I453717f867b8a49499576c28550e7c93053a0cf8 Reviewed-on: https://go-review.googlesource.com/19020 Run-TryBot: Ian Lance Taylor Reviewed-by: Russ Cox --- misc/cgo/errors/ptr.go | 104 +++++++++++++++++++++++++++++++++++------ src/runtime/cgocall.go | 8 ++++ 2 files changed, 98 insertions(+), 14 deletions(-) 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/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 { From 2d916bec968212c69dcff1da4c85943c529a11b5 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Wed, 27 Jan 2016 22:00:59 -0800 Subject: [PATCH 092/128] runtime: align stack in sigfwd for darwin/386 We might be forwarding to a C signal handler. C code expects the stack to be aligned. Should fix darwin/386 build: the testcarchive tests were hanging as the program got an endless series of SIGSEGV signals. Change-Id: Ia02485d3736a3c40e12259f02d25f842cf8e4d29 Reviewed-on: https://go-review.googlesource.com/19025 Run-TryBot: Ian Lance Taylor TryBot-Result: Gobot Gobot Reviewed-by: David Crawshaw Reviewed-by: Brad Fitzpatrick --- src/runtime/sys_darwin_386.s | 20 +++++++++++++------- 1 file changed, 13 insertions(+), 7 deletions(-) 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 From 6d61725c36a36eb9b5a5fddfeb3525e52fbe9762 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Thu, 28 Jan 2016 20:53:41 +0000 Subject: [PATCH 093/128] doc: don't imply that the new HTTP status 451 is from RFC 6585 From twitter bug report: https://twitter.com/ox/status/692737249411207168 Change-Id: Ic5f4eeb00d705217542db558edc25e206f6b640d Reviewed-on: https://go-review.googlesource.com/19050 Reviewed-by: Russ Cox --- doc/go1.6.html | 10 +++++----- 1 file changed, 5 insertions(+), 5 deletions(-) diff --git a/doc/go1.6.html b/doc/go1.6.html index 46a8f65db3f..92998ad46ca 100644 --- a/doc/go1.6.html +++ b/doc/go1.6.html @@ -752,13 +752,13 @@ Third, the Expect: 100-continue header (see Transport.ExpectContinueTimeout). Fourth, there are -five new error codes from RFC 6585: +five new error codes: StatusPreconditionRequired (428), StatusTooManyRequests (429), -StatusRequestHeaderFieldsTooLarge (431), -StatusUnavailableForLegalReasons (451)), -and -StatusNetworkAuthenticationRequired (511). +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. From f5e309012b2dc4d60b324e8d805345002bcdaec1 Mon Sep 17 00:00:00 2001 From: Rahul Chaudhry Date: Thu, 28 Jan 2016 16:33:35 -0800 Subject: [PATCH 094/128] unsafe: fix typo in documentation of valid Pointer->uintptr->Pointer conversions Change-Id: Ib669d5241372326a46361ee096570e960b7a957f Reviewed-on: https://go-review.googlesource.com/19082 Reviewed-by: Ian Lance Taylor --- src/unsafe/unsafe.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/unsafe/unsafe.go b/src/unsafe/unsafe.go index 33b31142192..532fa4aa229 100644 --- a/src/unsafe/unsafe.go +++ b/src/unsafe/unsafe.go @@ -63,7 +63,7 @@ type ArbitraryType int // (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 uintptr. +// by conversion to uintptr, addition of an offset, and conversion back to Pointer. // // p = unsafe.Pointer(uintptr(p) + offset) // From 1ab900e5f14d01f34fad75131eaa4cebe3bbe6ad Mon Sep 17 00:00:00 2001 From: Andrew Gerrand Date: Fri, 29 Jan 2016 16:44:16 +1100 Subject: [PATCH 095/128] doc: link to block example in go1.6 doc Fixes #14143 Change-Id: I2d77e55bc0b6bb42e11de291e0ddb5ad5d620646 Reviewed-on: https://go-review.googlesource.com/19110 Reviewed-by: Russ Cox --- doc/go1.6.html | 16 ++-------------- 1 file changed, 2 insertions(+), 14 deletions(-) diff --git a/doc/go1.6.html b/doc/go1.6.html index 92998ad46ca..b4a3900aa08 100644 --- a/doc/go1.6.html +++ b/doc/go1.6.html @@ -464,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

    From 2e08694d51490339d7ffc05add0f16bb6c443013 Mon Sep 17 00:00:00 2001 From: Mikio Hara Date: Thu, 28 Jan 2016 11:05:03 +0900 Subject: [PATCH 096/128] net: deflake TestListenerClose Fixes #14124. Change-Id: I9a694c402e613d27701e7e41640af357c373edea Reviewed-on: https://go-review.googlesource.com/18959 Reviewed-by: Ian Lance Taylor Run-TryBot: Russ Cox TryBot-Result: Gobot Gobot --- src/net/net_test.go | 24 ++++++++++++++++++++++-- 1 file changed, 22 insertions(+), 2 deletions(-) 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) From 0f89efa255a46eb6528d27c920030721ae68b507 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Fri, 29 Jan 2016 10:16:24 -0500 Subject: [PATCH 097/128] cmd/vet: report uncalled functions in Printf %v Given, say, var f *os.File, a new vet check in CL 14122 diagnoses: fmt.Printf("%s\n", f.Name) fmt.Println(f.Name) but not fmt.Printf("%v\n", f.Name) In all three cases the error is that the argument should be f.Name(). Diagnosing Println but not Printf %v seems oddly inconsistent, so I changed %v to have the check too. In fact, all verbs now have the check except %p and %T. Fixes Dave Cheney's confusion when trying to write an example of the new vet check advertised in the Go 1.6 release notes. Change-Id: I92fa6a7a1d5d9339a6a59ae4e587a254e633f500 Reviewed-on: https://go-review.googlesource.com/19101 Run-TryBot: Russ Cox Reviewed-by: Rob Pike --- src/cmd/vet/print.go | 8 ++++---- src/cmd/vet/testdata/print.go | 3 +++ 2 files changed, 7 insertions(+), 4 deletions(-) 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/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) From 9f58bf5f6b9ffd0c6e15d717fb741fd235339512 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Fri, 29 Jan 2016 12:18:32 -0500 Subject: [PATCH 098/128] cmd/go: avoid a few symlink-induced errors in internal and vendor checks This CL expands symlinks only when an error would be reported otherwise. Since the expansions are only on error paths, anything that worked yesterday should still work after this CL. This CL fixes a regression from Go 1.5 in "go run", or else we'd probably postpone it. Changing only the error paths is meant as a way to reduce the risk of making this change so late in the release cycle, but it may actually be the right strategy for symlinks in general. Fixes #14054. Change-Id: I42ed1276f67a0c395297a62bcec7d36c14c06404 Reviewed-on: https://go-review.googlesource.com/19102 Run-TryBot: Russ Cox TryBot-Result: Gobot Gobot Reviewed-by: Brad Fitzpatrick --- src/cmd/go/go_test.go | 54 ++++++++++++++++++++++++++++++++++++++++++- src/cmd/go/main.go | 9 ++++++++ src/cmd/go/pkg.go | 21 +++++++++++++++++ 3 files changed, 83 insertions(+), 1 deletion(-) diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go index a901ca8666c..0136ba4b1b1 100644 --- a/src/cmd/go/go_test.go +++ b/src/cmd/go/go_test.go @@ -1621,7 +1621,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) @@ -1640,6 +1640,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) diff --git a/src/cmd/go/main.go b/src/cmd/go/main.go index c8697ffe98c..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. diff --git a/src/cmd/go/pkg.go b/src/cmd/go/pkg.go index 112f820d802..95a06ffedcd 100644 --- a/src/cmd/go/pkg.go +++ b/src/cmd/go/pkg.go @@ -415,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 { @@ -533,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{ @@ -630,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{ From af15beeab5ff9cde411c3db086ca9a24ace4c898 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Fri, 29 Jan 2016 17:45:23 +0000 Subject: [PATCH 099/128] os: document that FindProcess always succeeds on Unix Fixes #14146 Change-Id: I892ca4ccdc1ba785750e1eae800852dc5825156c Reviewed-on: https://go-review.googlesource.com/19093 Reviewed-by: Russ Cox Run-TryBot: Brad Fitzpatrick --- src/os/doc.go | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) 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) } From d37d76af43f590935b13f2d33b07ef51c2976354 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Sat, 30 Jan 2016 14:29:02 -0800 Subject: [PATCH 100/128] cmd/compile: fix parsing of inlined interface types with unexported methods Fixes #14164. Change-Id: Ib1d1d29674c99cf88e0ae12724823a31f5dbb95c Reviewed-on: https://go-review.googlesource.com/19087 Run-TryBot: Robert Griesemer TryBot-Result: Gobot Gobot Reviewed-by: Russ Cox --- src/cmd/compile/internal/gc/parser.go | 18 ++++++++++ test/fixedbugs/issue14164.dir/a.go | 47 +++++++++++++++++++++++++++ test/fixedbugs/issue14164.dir/main.go | 12 +++++++ test/fixedbugs/issue14164.go | 7 ++++ 4 files changed, 84 insertions(+) create mode 100644 test/fixedbugs/issue14164.dir/a.go create mode 100644 test/fixedbugs/issue14164.dir/main.go create mode 100644 test/fixedbugs/issue14164.go diff --git a/src/cmd/compile/internal/gc/parser.go b/src/cmd/compile/internal/gc/parser.go index 282e855b37e..054cf736561 100644 --- a/src/cmd/compile/internal/gc/parser.go +++ b/src/cmd/compile/internal/gc/parser.go @@ -2501,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/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 From b3c05f08a97ac89064d3edbf4efb7bea671c2c18 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Fri, 29 Jan 2016 15:43:24 -0800 Subject: [PATCH 101/128] runtime: avoid write barrier in cgo mmap code Tested by hand with a runtime/cgo modified to return an mmap failure after 10 calls. This is an interim patch. For 1.7 we should fix mmap properly to avoid using the same value as both a pointer and an errno value. Fixes #14149. Change-Id: I8f2bbd47d711e283001ba73296f1c34a26c59241 Reviewed-on: https://go-review.googlesource.com/19084 TryBot-Result: Gobot Gobot Reviewed-by: Russ Cox --- src/runtime/cgo_mmap.go | 13 ++++++++++--- 1 file changed, 10 insertions(+), 3 deletions(-) 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 From 125f52dfa8ce6df0380b0bdc66effb8afd697bda Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Mon, 1 Feb 2016 22:16:42 +0000 Subject: [PATCH 102/128] net/http: update bundled http2, fix Transport memory leak Updates x/net/http2 to git rev 644ffc for three CLs since the last update: http2: don't add *Response to activeRes in Transport on Headers.END_STREAM https://golang.org/cl/19134 http2: add mechanism to send undeclared Trailers mid handler https://golang.org/cl/19131 http2: remove unused variable https://golang.org/cl/18936 The first in the list above is the main fix that's necessary. The other are two are in the git history but along for the cmd/bundle ride. The middle CL is well-tested, small (mostly comments), non-tricky, and almost never seen (since nobody really uses Trailers). The final CL is just deleting an unused global variable. Fixes #14084 again (with more tests) Change-Id: Iac51350acee9c51d32bf7779d57e9d5a5482b928 Reviewed-on: https://go-review.googlesource.com/19135 Run-TryBot: Brad Fitzpatrick Reviewed-by: Andrew Gerrand --- src/net/http/clientserver_test.go | 12 ++++-- src/net/http/h2_bundle.go | 67 +++++++++++++++++++++++++++++-- 2 files changed, 71 insertions(+), 8 deletions(-) diff --git a/src/net/http/clientserver_test.go b/src/net/http/clientserver_test.go index 9b581e73117..fbaa805712b 100644 --- a/src/net/http/clientserver_test.go +++ b/src/net/http/clientserver_test.go @@ -1001,13 +1001,17 @@ func TestTransportDiscardsUnneededConns(t *testing.T) { } // tests that Transport doesn't retain a pointer to the provided request. -func TestTransportGCRequest_h1(t *testing.T) { testTransportGCRequest(t, h1Mode) } -func TestTransportGCRequest_h2(t *testing.T) { testTransportGCRequest(t, h2Mode) } -func testTransportGCRequest(t *testing.T, h2 bool) { +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) - io.WriteString(w, "Hello.") + if body { + io.WriteString(w, "Hello.") + } })) defer cst.close() diff --git a/src/net/http/h2_bundle.go b/src/net/http/h2_bundle.go index e7236299e22..11f33cf3b18 100644 --- a/src/net/http/h2_bundle.go +++ b/src/net/http/h2_bundle.go @@ -2851,8 +2851,6 @@ func (sc *http2serverConn) logf(format string, args ...interface{}) { } } -var http2uintptrType = reflect.TypeOf(uintptr(0)) - // errno returns v's underlying uintptr, else 0. // // TODO: remove this helper function once http2 can use build @@ -4220,7 +4218,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 @@ -4288,6 +4288,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 { @@ -4308,6 +4312,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 { @@ -5611,10 +5662,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 @@ -6258,8 +6309,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 From f309bf3eeff8343e557a9798e42ac72b37da3f0a Mon Sep 17 00:00:00 2001 From: Austin Clements Date: Mon, 1 Feb 2016 14:06:51 -0500 Subject: [PATCH 103/128] runtime: start an M when handing off a P when there's GC work MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Currently it's possible for the scheduler to deadlock with the right confluence of locked Gs, assists, and scheduling of background mark workers. Broadly, this happens because handoffp is stricter than findrunnable, and if the only work for a P is GC work, handoffp will put the P into idle, rather than starting an M to execute that P. One way this can happen is as follows: 0. There is only one user G, which we'll call G 1. There is more than one P, but they're all idle except the one running G 1. 1. G 1 locks itself to an M using runtime.LockOSThread. 2. GC starts up and enters mark 1. 3. G 1 performs a GC assist, which completes mark 1 without being fully satisfied. Completing mark 1 causes all background mark workers to park. And since the assist isn't fully satisfied, it parks as well, waiting for a background mark worker to satisfy its remaining assist debt. 4. The assist park enters the scheduler. Since G 1 is locked to the M, the scheduler releases the P and calls handoffp to hand the P to another M. 5. handoffp checks the local and global run queues, which are empty, and sees that there are idle Ps, so rather than start an M, it puts the P into idle. At this point, all of the Gs are waiting and all of the Ps are idle. In particular, none of the GC workers are running, so no mark work gets done and the assist on the main G is never satisfied, so the whole process soft locks up. Fix this by making handoffp start an M if there is GC work. This reintroduces a key invariant: that in any situation where findrunnable would return a G to run on a P, handoffp for that P will start an M to run work on that P. Fixes #13645. Tested by running 2,689 iterations of `go tool dist test -no-rebuild runtime:cpu124` across 10 linux-amd64-noopt VMs with no failures. Without this change, the failure rate was somewhere around 1%. Performance change is negligible. name old time/op new time/op delta XBenchGarbage-12 2.48ms ± 2% 2.48ms ± 1% -0.24% (p=0.000 n=92+93) name old time/op new time/op delta BinaryTree17-12 2.86s ± 2% 2.87s ± 2% ~ (p=0.667 n=19+20) Fannkuch11-12 2.52s ± 1% 2.47s ± 1% -2.05% (p=0.000 n=18+20) FmtFprintfEmpty-12 51.7ns ± 1% 51.5ns ± 3% ~ (p=0.931 n=16+20) FmtFprintfString-12 170ns ± 1% 168ns ± 1% -0.65% (p=0.000 n=19+19) FmtFprintfInt-12 160ns ± 0% 160ns ± 0% +0.18% (p=0.033 n=17+19) FmtFprintfIntInt-12 265ns ± 1% 273ns ± 1% +2.98% (p=0.000 n=17+19) FmtFprintfPrefixedInt-12 235ns ± 1% 239ns ± 1% +1.99% (p=0.000 n=16+19) FmtFprintfFloat-12 315ns ± 0% 315ns ± 1% ~ (p=0.250 n=17+19) FmtManyArgs-12 1.04µs ± 1% 1.05µs ± 0% +0.87% (p=0.000 n=17+19) GobDecode-12 7.93ms ± 0% 7.85ms ± 1% -1.03% (p=0.000 n=16+18) GobEncode-12 6.62ms ± 1% 6.58ms ± 1% -0.60% (p=0.000 n=18+19) Gzip-12 322ms ± 1% 320ms ± 1% -0.46% (p=0.009 n=20+20) Gunzip-12 42.5ms ± 1% 42.5ms ± 0% ~ (p=0.751 n=19+19) HTTPClientServer-12 69.7µs ± 1% 70.0µs ± 2% ~ (p=0.056 n=19+19) JSONEncode-12 16.9ms ± 1% 16.7ms ± 1% -1.13% (p=0.000 n=19+19) JSONDecode-12 61.5ms ± 1% 61.3ms ± 1% -0.35% (p=0.001 n=20+17) Mandelbrot200-12 3.94ms ± 0% 3.91ms ± 0% -0.67% (p=0.000 n=20+18) GoParse-12 3.71ms ± 1% 3.70ms ± 1% ~ (p=0.244 n=17+19) RegexpMatchEasy0_32-12 101ns ± 1% 102ns ± 2% +0.54% (p=0.037 n=19+20) RegexpMatchEasy0_1K-12 349ns ± 0% 350ns ± 0% +0.33% (p=0.000 n=17+18) RegexpMatchEasy1_32-12 84.5ns ± 2% 84.2ns ± 1% -0.43% (p=0.048 n=19+20) RegexpMatchEasy1_1K-12 510ns ± 1% 513ns ± 2% +0.58% (p=0.002 n=18+20) RegexpMatchMedium_32-12 132ns ± 1% 134ns ± 1% +0.95% (p=0.000 n=20+20) RegexpMatchMedium_1K-12 40.1µs ± 1% 39.6µs ± 1% -1.39% (p=0.000 n=20+20) RegexpMatchHard_32-12 2.08µs ± 0% 2.06µs ± 1% -0.95% (p=0.000 n=18+18) RegexpMatchHard_1K-12 62.2µs ± 1% 61.9µs ± 1% -0.42% (p=0.001 n=19+20) Revcomp-12 537ms ± 0% 536ms ± 0% ~ (p=0.076 n=20+20) Template-12 71.3ms ± 1% 69.3ms ± 1% -2.75% (p=0.000 n=20+20) TimeParse-12 361ns ± 0% 360ns ± 1% ~ (p=0.056 n=19+19) TimeFormat-12 353ns ± 0% 352ns ± 0% -0.23% (p=0.000 n=17+18) [Geo mean] 62.6µs 62.5µs -0.17% Change-Id: I0fbbbe4d7d99653ba5600ffb4394fa03558bc4e9 Reviewed-on: https://go-review.googlesource.com/19107 Reviewed-by: Rick Hudson Reviewed-by: Russ Cox Run-TryBot: Austin Clements TryBot-Result: Gobot Gobot --- src/runtime/proc.go | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/src/runtime/proc.go b/src/runtime/proc.go index 2bc3c920dc6..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() From 1c6a35b4fe894ab0dc229be35d8a5fb0080a31d6 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 2 Feb 2016 10:15:34 -0500 Subject: [PATCH 104/128] runtime: deflake TestGoroutineProfileTrivial Failed at https://storage.googleapis.com/go-build-log/9875de36/nacl-amd64p32_931ba6cf.log Change-Id: I2bc204ed58da543ee2534b69c29c8e8485d54683 Reviewed-on: https://go-review.googlesource.com/19155 Run-TryBot: Russ Cox Reviewed-by: Brad Fitzpatrick Reviewed-by: Austin Clements TryBot-Result: Gobot Gobot --- src/runtime/runtime_test.go | 25 +++++++++++++++++-------- 1 file changed, 17 insertions(+), 8 deletions(-) diff --git a/src/runtime/runtime_test.go b/src/runtime/runtime_test.go index 581f52bcb08..a6150a77ee9 100644 --- a/src/runtime/runtime_test.go +++ b/src/runtime/runtime_test.go @@ -310,13 +310,22 @@ func TestAppendSliceGrowth(t *testing.T) { } func TestGoroutineProfileTrivial(t *testing.T) { - 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 { - t.Fatalf("GoroutineProfile(%d) = %d, %v, want %d, true", n1, n2, ok, n1) + // 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") + } } } From 8de7563acd813e742bcf7db0a6ab19203dbf6b28 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 2 Feb 2016 10:10:27 -0500 Subject: [PATCH 105/128] cmd/go: avoid use of git -C, which does not exist in RHEL 7 Tested manually with "go test -run TestGetSubmodules". Fixes #14194. Change-Id: I4f563b2b8a38f3040d7631f74a7908ab65e0860b Reviewed-on: https://go-review.googlesource.com/19154 Reviewed-by: Brad Fitzpatrick --- src/cmd/go/vcs.go | 11 ++++++++++- 1 file changed, 10 insertions(+), 1 deletion(-) 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, From b6c5edae7c0e9dd6d12dbb8f1c9638dea45f9464 Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Mon, 1 Feb 2016 22:02:52 -0500 Subject: [PATCH 106/128] =?UTF-8?q?archive/zip:=20handle=20pre-zip64=20zip?= =?UTF-8?q?=20files=20containing=202=C2=B3=C2=B2-1-byte=20content?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit This corrects a regression from Go 1.5 introduced by CL 18317. Fixes #14185. Change-Id: Ic3215714846d9f28809cd04e3eb3664b599244f4 Reviewed-on: https://go-review.googlesource.com/19151 Reviewed-by: Brad Fitzpatrick --- src/archive/zip/reader.go | 12 +- src/archive/zip/reader_test.go | 235 +++++++++++++++++++++++++++++++-- 2 files changed, 236 insertions(+), 11 deletions(-) diff --git a/src/archive/zip/reader.go b/src/archive/zip/reader.go index 84a9d41888d..10e81728757 100644 --- a/src/archive/zip/reader.go +++ b/src/archive/zip/reader.go @@ -330,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{ From eb5bfa71717b30741f2a3e94a5669a3b55498ad4 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Tue, 2 Feb 2016 16:05:47 +0000 Subject: [PATCH 107/128] net/http: mark TestTLSServerClosesConnection as flaky on all systems Fixes #14195 Change-Id: I245b3ca3fd7d1a76aa95f2e058f8432ba5ce31ee Reviewed-on: https://go-review.googlesource.com/19160 Run-TryBot: Brad Fitzpatrick Reviewed-by: Austin Clements Reviewed-by: Russ Cox --- src/net/http/transport_test.go | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) 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") { From 2639498f9b5e43dfceb6aa7aafb31bc313216e24 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Mon, 1 Feb 2016 15:58:34 +0000 Subject: [PATCH 108/128] net/http/httputil: fix spelling of Trailer hop-by-hop header per errata RFC Errata 4522 (http://www.rfc-editor.org/errata_search.php?eid=4522) notes that RFC 2616 had a typo in a list of headers that the httputil.ReverseProxy code copied. Fix the typo in our code. Fixes #14174 Change-Id: Ifc8f18fd58a6508a02a23e54ff3c473f03e521d3 Reviewed-on: https://go-review.googlesource.com/19133 Reviewed-by: Russ Cox Run-TryBot: Brad Fitzpatrick TryBot-Result: Gobot Gobot --- src/net/http/httputil/reverseproxy.go | 4 ++-- src/net/http/httputil/reverseproxy_test.go | 4 ++++ 2 files changed, 6 insertions(+), 2 deletions(-) diff --git a/src/net/http/httputil/reverseproxy.go b/src/net/http/httputil/reverseproxy.go index 4dba352a4fa..38987d7a741 100644 --- a/src/net/http/httputil/reverseproxy.go +++ b/src/net/http/httputil/reverseproxy.go @@ -109,8 +109,8 @@ var hopHeaders = []string{ "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..72662ccdc5c 100644 --- a/src/net/http/httputil/reverseproxy_test.go +++ b/src/net/http/httputil/reverseproxy_test.go @@ -48,6 +48,7 @@ func TestReverseProxy(t *testing.T) { 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") @@ -86,6 +87,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) } From beceea733970b5267e61cd301507b78fc05d8d48 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Tue, 2 Feb 2016 17:34:48 +0000 Subject: [PATCH 109/128] runtime/pprof: mark dragonfly and solaris as bad at pprof Updates #13841 Change-Id: I121bce054e2756c820c76444e51357f474b7f3d6 Reviewed-on: https://go-review.googlesource.com/19161 Reviewed-by: Russ Cox --- src/runtime/pprof/pprof_test.go | 14 ++++++++------ 1 file changed, 8 insertions(+), 6 deletions(-) diff --git a/src/runtime/pprof/pprof_test.go b/src/runtime/pprof/pprof_test.go index 621d21d3272..ab6b1835c57 100644 --- a/src/runtime/pprof/pprof_test.go +++ b/src/runtime/pprof/pprof_test.go @@ -96,7 +96,7 @@ func parseProfile(t *testing.T, bytes []byte, f func(uintptr, []uintptr)) { 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() @@ -171,7 +171,7 @@ func testCPUProfile(t *testing.T, need []string, f func(dur time.Duration)) { } 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 } // Ignore the failure if the tests are running in a QEMU-based emulator, @@ -420,11 +420,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) { From 224888655fbbdf4a6d7a792d17dd95851e9b86aa Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Mon, 1 Feb 2016 22:07:06 -0500 Subject: [PATCH 110/128] cmd/go: document that -msan requires clang Fixes #14171. Change-Id: Ie75c1cfd88801618308d472bc04e7fc648c95e0c Reviewed-on: https://go-review.googlesource.com/19150 Reviewed-by: Brad Fitzpatrick Reviewed-by: Ian Lance Taylor Run-TryBot: Russ Cox TryBot-Result: Gobot Gobot --- src/cmd/go/alldocs.go | 3 ++- src/cmd/go/build.go | 3 ++- 2 files changed, 4 insertions(+), 2 deletions(-) diff --git a/src/cmd/go/alldocs.go b/src/cmd/go/alldocs.go index 5db4bc6beca..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 diff --git a/src/cmd/go/build.go b/src/cmd/go/build.go index 12867004aad..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 From 4760b5a478f9760e82819439843bca92085281d5 Mon Sep 17 00:00:00 2001 From: Rob Pike Date: Tue, 2 Feb 2016 13:46:49 -0800 Subject: [PATCH 111/128] misc: update timezone database to IANA 2016a Fixes #14202 Change-Id: Ia6dccecb1b9b3f6c0838c99090e6ddf1ad43303c Reviewed-on: https://go-review.googlesource.com/19175 Run-TryBot: Rob Pike TryBot-Result: Gobot Gobot Reviewed-by: Russ Cox --- lib/time/update.bash | 4 ++-- lib/time/zoneinfo.zip | Bin 360617 -> 360703 bytes 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/lib/time/update.bash b/lib/time/update.bash index 3ffadc2ab4c..86b1f211000 100755 --- a/lib/time/update.bash +++ b/lib/time/update.bash @@ -8,8 +8,8 @@ # Consult http://www.iana.org/time-zones for the latest versions. # Versions to use. -CODE=2015g -DATA=2015g +CODE=2016a +DATA=2016a set -e rm -rf work diff --git a/lib/time/zoneinfo.zip b/lib/time/zoneinfo.zip index 740d81988b194a75737abfae5c1005e5bf2a6d53..0207d6bcbc6a1edc4372b2d4737a108344982866 100644 GIT binary patch delta 66003 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 delta 66429 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 DCD!?M From 182a9db2dc57ec7da98391f8955d43b2e07fd40e Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Tue, 2 Feb 2016 13:23:32 -0800 Subject: [PATCH 112/128] cmd/vet: don't crash in cgo checker if type is unknown Fixes #14201. Change-Id: Ib61f8c00cae72463f59b90ae199fbdc1e7422a79 Reviewed-on: https://go-review.googlesource.com/19174 Run-TryBot: Ian Lance Taylor TryBot-Result: Gobot Gobot Reviewed-by: Michael Hudson-Doyle Reviewed-by: Brad Fitzpatrick Reviewed-by: Russ Cox --- src/cmd/vet/cgo.go | 3 +++ src/cmd/vet/testdata/cgo2.go | 9 +++++++++ 2 files changed, 12 insertions(+) create mode 100644 src/cmd/vet/testdata/cgo2.go 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/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)) From 0ed70efc6b7ec096603c58f27c2668af3862bb3c Mon Sep 17 00:00:00 2001 From: Russ Cox Date: Tue, 2 Feb 2016 09:19:47 -0500 Subject: [PATCH 113/128] cmd/go: fix rebuild after installation of new Go release The loading of zversion.go was expecting it to be in package runtime, but it moved to runtime/internal/sys. Worse, the load was not checking the error. Update the path, check the error, add a test. Fixes #14176. Change-Id: I203c40afe1448875581415d5e42c29f09b14545d Reviewed-on: https://go-review.googlesource.com/19180 Run-TryBot: Russ Cox Reviewed-by: Brad Fitzpatrick TryBot-Result: Gobot Gobot --- src/cmd/go/go_test.go | 86 +++++++++++++++++++++++++++++++++++++++---- src/cmd/go/pkg.go | 9 +++-- 2 files changed, 85 insertions(+), 10 deletions(-) diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go index 0136ba4b1b1..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) { @@ -672,11 +675,80 @@ func TestGoBuildDashAInReleaseBranch(t *testing.T) { 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) { @@ -756,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) @@ -766,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) { diff --git a/src/cmd/go/pkg.go b/src/cmd/go/pkg.go index 95a06ffedcd..a804ccd277c 100644 --- a/src/cmd/go/pkg.go +++ b/src/cmd/go/pkg.go @@ -1542,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)) } From 03f42ee3a561100f99bd98c3a52780536a422ab7 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Wed, 3 Feb 2016 16:58:43 +0000 Subject: [PATCH 114/128] sync: deflake TestWaitGroupMisuse3 Previous flakes: https://build.golang.org/log/223365dedb6b6aa0cfdf5afd0a50fd433a16bade https://build.golang.org/log/edbea4cd3f24e707ef2ae8378559bb0fcc453c22 Dmitry says in email about this: > The stack trace points to it pretty clearly. Done can indeed unblock > Wait first and then panic. I guess we need to recover after first > Done as well. And it looks like TestWaitGroupMisuse2 was already hardened against this. Do the same in TestWaitGroupMisuse3. Change-Id: I317800c7e46f13c97873f0873c759a489dd5f47d Reviewed-on: https://go-review.googlesource.com/19183 Reviewed-by: Dmitry Vyukov Reviewed-by: Austin Clements Reviewed-by: Russ Cox Run-TryBot: Brad Fitzpatrick TryBot-Result: Gobot Gobot --- src/sync/waitgroup_test.go | 11 ++++++++--- 1 file changed, 8 insertions(+), 3 deletions(-) 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") From 91911e39f0fdfecc5453f9eca7ff74215ffb28a2 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Wed, 3 Feb 2016 21:35:03 +0000 Subject: [PATCH 115/128] net/http/httputil: also remove non-standard Proxy-Connection hop-by-hop header libcurl sends this (despite never being standardized), and the Google GFE rejects it with a 400 bad request (but only when over http2?). So nuke it. Change-Id: I3fc95523d50f33a0e23bb26b9195f70ab0aed0f4 Reviewed-on: https://go-review.googlesource.com/19184 Reviewed-by: Chris Broadfoot Run-TryBot: Brad Fitzpatrick --- src/net/http/httputil/reverseproxy.go | 1 + src/net/http/httputil/reverseproxy_test.go | 4 ++++ 2 files changed, 5 insertions(+) diff --git a/src/net/http/httputil/reverseproxy.go b/src/net/http/httputil/reverseproxy.go index 38987d7a741..54411caeca8 100644 --- a/src/net/http/httputil/reverseproxy.go +++ b/src/net/http/httputil/reverseproxy.go @@ -106,6 +106,7 @@ 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", diff --git a/src/net/http/httputil/reverseproxy_test.go b/src/net/http/httputil/reverseproxy_test.go index 72662ccdc5c..0849427b85c 100644 --- a/src/net/http/httputil/reverseproxy_test.go +++ b/src/net/http/httputil/reverseproxy_test.go @@ -45,6 +45,9 @@ 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) } @@ -72,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) From fd24e6d561d672362ebe4a8231aa43f1c54b164a Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Wed, 3 Feb 2016 18:56:24 -0800 Subject: [PATCH 116/128] doc: correct old function names in strconv comments in go1.6 doc Fixes #14219. Change-Id: Id398dcfe6e9978d7eefddcdaaaa2256c16237cf3 Reviewed-on: https://go-review.googlesource.com/19207 Run-TryBot: Ian Lance Taylor TryBot-Result: Gobot Gobot Reviewed-by: Brad Fitzpatrick Reviewed-by: Minux Ma --- doc/go1.6.html | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/doc/go1.6.html b/doc/go1.6.html index b4a3900aa08..6e3710cbad2 100644 --- a/doc/go1.6.html +++ b/doc/go1.6.html @@ -875,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).
    • From 1f7e3cfdbcc4b12ba769bb5e9e09887145870187 Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Wed, 3 Feb 2016 21:49:45 -0800 Subject: [PATCH 117/128] runtime: skip TestSignalExitStatus on Solaris Update #14063. Change-Id: Id13456deb15c90a8af282b77d78ff5cdbd1de8bf Reviewed-on: https://go-review.googlesource.com/19208 Run-TryBot: Ian Lance Taylor Reviewed-by: Minux Ma TryBot-Result: Gobot Gobot --- src/runtime/crash_unix_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/src/runtime/crash_unix_test.go b/src/runtime/crash_unix_test.go index 5284a37b0f1..1a012eb6ef1 100644 --- a/src/runtime/crash_unix_test.go +++ b/src/runtime/crash_unix_test.go @@ -137,8 +137,8 @@ func loop(i int, c chan bool) { func TestSignalExitStatus(t *testing.T) { testenv.MustHaveGoBuild(t) switch runtime.GOOS { - case "netbsd": - t.Skip("skipping on NetBSD; see https://golang.org/issue/14063") + case "netbsd", "solaris": + t.Skipf("skipping on %s; see https://golang.org/issue/14063", runtime.GOOS) } exe, err := buildTestProg(t, "testprog") if err != nil { From 39304eb69d7f6117e60630452c0e037dbb555f5e Mon Sep 17 00:00:00 2001 From: Andrew Gerrand Date: Fri, 5 Feb 2016 09:43:46 +1100 Subject: [PATCH 118/128] doc: rewrite references to plan9.bell-labs.com to 9p.io The plan9.bell-labs.com site has fallen into disrepair. We'll instead use the site maintained by contributor David du Colombier. Fixes #14233 Change-Id: I0c702e5d3b091cccd42b288ea32f34d507a4733d Reviewed-on: https://go-review.googlesource.com/19240 Reviewed-by: Brad Fitzpatrick Reviewed-by: David du Colombier <0intro@gmail.com> --- doc/asm.html | 4 ++-- doc/codewalk/codewalk.xml | 2 +- doc/go_faq.html | 2 +- 3 files changed, 4 insertions(+), 4 deletions(-) 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/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 From 4d02b1241738a5bd06201455a4f74a013f6c9437 Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 4 Feb 2016 13:38:38 -0800 Subject: [PATCH 119/128] runtime: don't expose stack buffer in stringto{byte,rune}slice When using a stack-allocated buffer for the result, don't expose the uninitialized portion of it by restricting its capacity to its length. The other option is to zero the portion between len and cap. That seems like more work, but might be worth it if the caller then appends some stuff to the result. But this close to 1.6, I'm inclined to do the simplest fix possible. Fixes #14232 Change-Id: I21c50d3cda02fd2df4d60ba5e2cfe2efe272f333 Reviewed-on: https://go-review.googlesource.com/19231 Reviewed-by: Brad Fitzpatrick Reviewed-by: Ian Lance Taylor --- src/runtime/string.go | 4 ++-- src/runtime/string_test.go | 15 +++++++++++++++ 2 files changed, 17 insertions(+), 2 deletions(-) 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)) + } +} From 107a6ef41f3518aba8d791cdb11bb5e63a2e16b9 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Thu, 4 Feb 2016 19:40:38 +0000 Subject: [PATCH 120/128] net/http: document Request.Header and Request.Close more Updates #14227 Change-Id: If39f11471ecd307c9483f64e73f9c89fe906ae71 Reviewed-on: https://go-review.googlesource.com/19222 Reviewed-by: Andrew Gerrand Reviewed-by: Russ Cox --- src/net/http/request.go | 40 +++++++++++++++++++++++++++------------- 1 file changed, 27 insertions(+), 13 deletions(-) diff --git a/src/net/http/request.go b/src/net/http/request.go index 16c5bb43ac4..03f3e2b9747 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. + // + // The 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 From dc89b5b48f0c1c9a73c6e0dbbae514ffc55788c8 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Fri, 5 Feb 2016 01:44:52 +0000 Subject: [PATCH 121/128] net/http: update bundled http2 Updates x/net/http2 to git rev 493a262 for https://golang.org/cl/19223 Fixes #14227 Change-Id: I626122811138fb3d88e4eea83f8da3fdcf91e0dc Reviewed-on: https://go-review.googlesource.com/19250 Reviewed-by: Brad Fitzpatrick Run-TryBot: Brad Fitzpatrick TryBot-Result: Gobot Gobot --- src/net/http/h2_bundle.go | 117 +++++++++++++++++++++++++++++++------- 1 file changed, 97 insertions(+), 20 deletions(-) diff --git a/src/net/http/h2_bundle.go b/src/net/http/h2_bundle.go index 11f33cf3b18..c4faccc7a8d 100644 --- a/src/net/http/h2_bundle.go +++ b/src/net/http/h2_bundle.go @@ -2331,6 +2331,10 @@ var http2isTokenTable = [127]bool{ '~': 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) @@ -2593,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, }, @@ -2630,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() @@ -2646,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 @@ -4874,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 } @@ -5028,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 @@ -5334,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 { @@ -5445,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 @@ -5503,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() @@ -5552,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() } } @@ -5803,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() { From fd9fd4c39d92f6f177d22b39e8ee000ae01a9511 Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Fri, 5 Feb 2016 15:05:35 +0000 Subject: [PATCH 122/128] net/http: fix doc typo Change-Id: I93201fa4152f2d60b3eedb8d321a152819033121 Reviewed-on: https://go-review.googlesource.com/19270 Reviewed-by: Ian Lance Taylor --- src/net/http/request.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/net/http/request.go b/src/net/http/request.go index 03f3e2b9747..8cdab02af5a 100644 --- a/src/net/http/request.go +++ b/src/net/http/request.go @@ -165,7 +165,7 @@ type Request struct { // For server requests, the HTTP server handles this automatically // and this field is not needed by Handlers. // - // The client requests, setting this field prevents re-use of + // 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 From 54b4b946b67ab28fc8695f1fa26b98f21d366fdb Mon Sep 17 00:00:00 2001 From: Ian Lance Taylor Date: Fri, 5 Feb 2016 14:59:46 -0800 Subject: [PATCH 123/128] net/http: deflake TestCloseNotifierPipelined The test sends two HTTP/1.1 pipelined requests. The first is completedly by the second, and as such triggers an immediate call to the CloseNotify channel. The second calls the CloseNotify channel after the overall connection is closed. The test was passing fine on gc because the code would enter the select loop before running the handler, so the send on gotReq would always be seen first. On gccgo the code would sometimes enter the select loop after the handler had already finished, meaning that the select could choose between gotReq and sawClose. If it picked sawClose, it would never close the overall connection, and the httptest server would hang. The same hang could be induced with gc by adding a time.Sleep immediately before the select loop. Deflake the test by 1) don't close the overall connection until both requests have been seen; 2) don't exit the loop until both closes have been seen. Fixes #14231. Change-Id: I9d20c309125422ce60ac545f78bcfa337aec1c7d Reviewed-on: https://go-review.googlesource.com/19281 Reviewed-by: Brad Fitzpatrick Run-TryBot: Ian Lance Taylor TryBot-Result: Gobot Gobot --- src/net/http/serve_test.go | 16 +++++++++++++--- 1 file changed, 13 insertions(+), 3 deletions(-) diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go index f8cad802d49..f7df776389f 100644 --- a/src/net/http/serve_test.go +++ b/src/net/http/serve_test.go @@ -2416,7 +2416,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 +2426,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") From fa5e5478c8791d644c3d7b07a73680f87eb5a43b Mon Sep 17 00:00:00 2001 From: Mikio Hara Date: Fri, 5 Feb 2016 09:37:13 +0900 Subject: [PATCH 124/128] runtime: don't call testing.Fatal from worker goroutines Change-Id: I630d4d2d8a914d6c07f22351a56d5e44a937123e Reviewed-on: https://go-review.googlesource.com/19245 Reviewed-by: Brad Fitzpatrick --- src/runtime/stack_test.go | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) 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() } From 33a9a98e4d5893699749f75334c651b2adcecfb9 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Fri, 5 Feb 2016 15:23:47 -0800 Subject: [PATCH 125/128] go/types: make sure constants valid in integer operations are in integer form The operation where this manifested in a crash was % (only defined on integers). However, the existing code was sloppy in that it didn't retain the integer form after a value (e.g., 3.0) was accepted as representable in integer form (3 for the example). We would have seen a crash in such cases for / as well except that there was code to fix it for just that case. Remove the special code for / and fix more generally by retaining the integer form for all operations if applicable. Fixes #14229. Change-Id: I8bef769e6299839fade27c6e8b5ff29ad6521d0d Reviewed-on: https://go-review.googlesource.com/19300 Reviewed-by: Alan Donovan --- src/go/types/expr.go | 8 +++++--- src/go/types/testdata/issues.src | 17 +++++++++++++++++ 2 files changed, 22 insertions(+), 3 deletions(-) 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 + ) +} From 77b4c8d9af0bfad762db7bb9bbc1793c5a233acd Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Mon, 8 Feb 2016 21:10:18 +0000 Subject: [PATCH 126/128] runtime: fix comment Fixes #14259 Change-Id: I23fedec0eb85ae28e56bc24539bc864674856130 Reviewed-on: https://go-review.googlesource.com/19318 Reviewed-by: Ian Lance Taylor --- src/runtime/time.go | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) 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 From 41191e192cb3d499ca8a2552117029493c6be1a9 Mon Sep 17 00:00:00 2001 From: Robert Griesemer Date: Mon, 8 Feb 2016 14:50:45 -0800 Subject: [PATCH 127/128] go/constant: fix String() implementation Fixes #14262. Change-Id: Id590995dd4460e81f6b91bcfb3f02515a97650fe Reviewed-on: https://go-review.googlesource.com/19361 Run-TryBot: Robert Griesemer Reviewed-by: Alan Donovan TryBot-Result: Gobot Gobot --- src/go/constant/value.go | 2 +- src/go/constant/value_test.go | 2 ++ 2 files changed, 3 insertions(+), 1 deletion(-) 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"}, From 6a208efbdfa939dc236a63383df19c7ab44aa50a Mon Sep 17 00:00:00 2001 From: Brad Fitzpatrick Date: Mon, 8 Feb 2016 23:23:36 +0000 Subject: [PATCH 128/128] net/http: make ListenAndServeTLS treat GetCertificate as a set cert too ListenAndServeTLS doesn't require cert and key file names if the server's TLSConfig has a cert configured. This code was never updated when the GetCertificate hook was added to *tls.Config, however. Fixes #14268 Change-Id: Ib282ebb05697edd37ed8ff105972cbd1176d900b Reviewed-on: https://go-review.googlesource.com/19381 Reviewed-by: Russ Cox --- src/net/http/serve_test.go | 28 ++++++++++++++++++++++------ src/net/http/server.go | 12 +++++++----- 2 files changed, 29 insertions(+), 11 deletions(-) diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go index f7df776389f..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("", "") }() diff --git a/src/net/http/server.go b/src/net/http/server.go index 004a1f92fc4..5e3b6084ae3 100644 --- a/src/net/http/server.go +++ b/src/net/http/server.go @@ -2233,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. // @@ -2258,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)