diff --git a/0001-release-branch.go1.17-crypto-elliptic-tolerate-zero-.patch b/0001-release-branch.go1.17-crypto-elliptic-tolerate-zero-.patch new file mode 100644 index 0000000000000000000000000000000000000000..6f993e03193c56d30da7f26fdb8cbdc9c9e95ebd --- /dev/null +++ b/0001-release-branch.go1.17-crypto-elliptic-tolerate-zero-.patch @@ -0,0 +1,60 @@ +From ad33fdc8f4bce612842d922ca701c3062fe4d4c6 Mon Sep 17 00:00:00 2001 +From: Filippo Valsorda +Date: Thu, 31 Mar 2022 12:31:58 -0400 +Subject: [Backport 1/2] [release-branch.go1.17] crypto/elliptic: tolerate + zero-padded scalars in generic P-256 + +Updates #52075 +Fixes #52076 +Fixes CVE-2022-28327 + +Change-Id: I595a7514c9a0aa1b9c76aedfc2307e1124271f27 +Reviewed-on: https://go-review.googlesource.com/c/go/+/397136 +Trust: Filippo Valsorda +Reviewed-by: Julie Qiu + +Conflict:NA +Reference:https://go-review.googlesource.com/c/go/+/399816,https://go-review.googlesource.com/c/go/+/397136 +--- + src/crypto/elliptic/p256.go | 2 +- + src/crypto/elliptic/p256_test.go | 14 ++++++++++++++ + 2 files changed, 15 insertions(+), 1 deletion(-) + +diff --git a/src/crypto/elliptic/p256.go b/src/crypto/elliptic/p256.go +index b2b12c8f13..da5283735c 100644 +--- a/src/crypto/elliptic/p256.go ++++ b/src/crypto/elliptic/p256.go +@@ -52,7 +52,7 @@ func p256GetScalar(out *[32]byte, in []byte) { + n := new(big.Int).SetBytes(in) + var scalarBytes []byte + +- if n.Cmp(p256Params.N) >= 0 { ++ if n.Cmp(p256Params.N) >= 0 || len(in) > len(out) { + n.Mod(n, p256Params.N) + scalarBytes = n.Bytes() + } else { +diff --git a/src/crypto/elliptic/p256_test.go b/src/crypto/elliptic/p256_test.go +index 1435f5e1a5..694186df81 100644 +--- a/src/crypto/elliptic/p256_test.go ++++ b/src/crypto/elliptic/p256_test.go +@@ -153,3 +153,17 @@ func TestP256CombinedMult(t *testing.T) { + t.Errorf("1×G + (-1)×G = (%d, %d), should be ∞", x, y) + } + } ++ ++func TestIssue52075(t *testing.T) { ++ Gx, Gy := P256().Params().Gx, P256().Params().Gy ++ scalar := make([]byte, 33) ++ scalar[32] = 1 ++ x, y := P256().ScalarBaseMult(scalar) ++ if x.Cmp(Gx) != 0 || y.Cmp(Gy) != 0 { ++ t.Errorf("unexpected output (%v,%v)", x, y) ++ } ++ x, y = P256().ScalarMult(Gx, Gy, scalar) ++ if x.Cmp(Gx) != 0 || y.Cmp(Gy) != 0 { ++ t.Errorf("unexpected output (%v,%v)", x, y) ++ } ++} +-- +2.30.0 + diff --git a/0002-release-branch.go1.17-encoding-pem-fix-stack-overflo.patch b/0002-release-branch.go1.17-encoding-pem-fix-stack-overflo.patch new file mode 100644 index 0000000000000000000000000000000000000000..243596c90ead364fc953a1fd4144479adb812e12 --- /dev/null +++ b/0002-release-branch.go1.17-encoding-pem-fix-stack-overflo.patch @@ -0,0 +1,291 @@ +From baaaf3ce29bf98efc00c2f06c531f2b0186b027b Mon Sep 17 00:00:00 2001 +From: Julie Qiu +Date: Tue, 1 Mar 2022 10:19:38 -0600 +Subject: [Backport 2/2] [release-branch.go1.17] encoding/pem: fix stack + overflow in Decode + +Previously, Decode called decodeError, a recursive function that was +prone to stack overflows when given a large PEM file containing errors. + +Credit to Juho Nurminen of Mattermost who reported the error. + +Fixes CVE-2022-24675 +Updates #51853 +Fixes #52036 + +Change-Id: Iffe768be53c8ddc0036fea0671d290f8f797692c +Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1391157 +Reviewed-by: Damien Neil +Reviewed-by: Filippo Valsorda +(cherry picked from commit 794ea5e828010e8b68493b2fc6d2963263195a02) +Reviewed-on: https://go-review.googlesource.com/c/go/+/399816 +Run-TryBot: Dmitri Shuralyov +Reviewed-by: Dmitri Shuralyov +Reviewed-by: Cherry Mui +TryBot-Result: Gopher Robot + +Conflict: NA +Reference: https://go-review.googlesource.com/c/go/+/399816 +--- + src/encoding/pem/pem.go | 174 +++++++++++++++-------------------- + src/encoding/pem/pem_test.go | 28 +++++- + 2 files changed, 101 insertions(+), 101 deletions(-) + +diff --git a/src/encoding/pem/pem.go b/src/encoding/pem/pem.go +index a7272da5ad..1bee1c12d2 100644 +--- a/src/encoding/pem/pem.go ++++ b/src/encoding/pem/pem.go +@@ -87,123 +87,97 @@ func Decode(data []byte) (p *Block, rest []byte) { + // pemStart begins with a newline. However, at the very beginning of + // the byte array, we'll accept the start string without it. + rest = data +- if bytes.HasPrefix(data, pemStart[1:]) { +- rest = rest[len(pemStart)-1 : len(data)] +- } else if i := bytes.Index(data, pemStart); i >= 0 { +- rest = rest[i+len(pemStart) : len(data)] +- } else { +- return nil, data +- } +- +- typeLine, rest := getLine(rest) +- if !bytes.HasSuffix(typeLine, pemEndOfLine) { +- return decodeError(data, rest) +- } +- typeLine = typeLine[0 : len(typeLine)-len(pemEndOfLine)] +- +- p = &Block{ +- Headers: make(map[string]string), +- Type: string(typeLine), +- } +- + for { +- // This loop terminates because getLine's second result is +- // always smaller than its argument. +- if len(rest) == 0 { ++ if bytes.HasPrefix(rest, pemStart[1:]) { ++ rest = rest[len(pemStart)-1:] ++ } else if i := bytes.Index(rest, pemStart); i >= 0 { ++ rest = rest[i+len(pemStart) : len(rest)] ++ } else { + return nil, data + } +- line, next := getLine(rest) + +- i := bytes.IndexByte(line, ':') +- if i == -1 { +- break ++ var typeLine []byte ++ typeLine, rest = getLine(rest) ++ if !bytes.HasSuffix(typeLine, pemEndOfLine) { ++ continue + } ++ typeLine = typeLine[0 : len(typeLine)-len(pemEndOfLine)] + +- // TODO(agl): need to cope with values that spread across lines. +- key, val := line[:i], line[i+1:] +- key = bytes.TrimSpace(key) +- val = bytes.TrimSpace(val) +- p.Headers[string(key)] = string(val) +- rest = next +- } ++ p = &Block{ ++ Headers: make(map[string]string), ++ Type: string(typeLine), ++ } + +- var endIndex, endTrailerIndex int ++ for { ++ // This loop terminates because getLine's second result is ++ // always smaller than its argument. ++ if len(rest) == 0 { ++ return nil, data ++ } ++ line, next := getLine(rest) + +- // If there were no headers, the END line might occur +- // immediately, without a leading newline. +- if len(p.Headers) == 0 && bytes.HasPrefix(rest, pemEnd[1:]) { +- endIndex = 0 +- endTrailerIndex = len(pemEnd) - 1 +- } else { +- endIndex = bytes.Index(rest, pemEnd) +- endTrailerIndex = endIndex + len(pemEnd) +- } ++ i := bytes.IndexByte(line, ':') ++ if i == -1 { ++ break ++ } + +- if endIndex < 0 { +- return decodeError(data, rest) +- } ++ // TODO(agl): need to cope with values that spread across lines. ++ key, val := line[:i], line[i+1:] ++ key = bytes.TrimSpace(key) ++ val = bytes.TrimSpace(val) ++ p.Headers[string(key)] = string(val) ++ rest = next ++ } + +- // After the "-----" of the ending line, there should be the same type +- // and then a final five dashes. +- endTrailer := rest[endTrailerIndex:] +- endTrailerLen := len(typeLine) + len(pemEndOfLine) +- if len(endTrailer) < endTrailerLen { +- return decodeError(data, rest) +- } ++ var endIndex, endTrailerIndex int + +- restOfEndLine := endTrailer[endTrailerLen:] +- endTrailer = endTrailer[:endTrailerLen] +- if !bytes.HasPrefix(endTrailer, typeLine) || +- !bytes.HasSuffix(endTrailer, pemEndOfLine) { +- return decodeError(data, rest) +- } ++ // If there were no headers, the END line might occur ++ // immediately, without a leading newline. ++ if len(p.Headers) == 0 && bytes.HasPrefix(rest, pemEnd[1:]) { ++ endIndex = 0 ++ endTrailerIndex = len(pemEnd) - 1 ++ } else { ++ endIndex = bytes.Index(rest, pemEnd) ++ endTrailerIndex = endIndex + len(pemEnd) ++ } + +- // The line must end with only whitespace. +- if s, _ := getLine(restOfEndLine); len(s) != 0 { +- return decodeError(data, rest) +- } ++ if endIndex < 0 { ++ continue ++ } + +- base64Data := removeSpacesAndTabs(rest[:endIndex]) +- p.Bytes = make([]byte, base64.StdEncoding.DecodedLen(len(base64Data))) +- n, err := base64.StdEncoding.Decode(p.Bytes, base64Data) +- if err != nil { +- return decodeError(data, rest) +- } +- p.Bytes = p.Bytes[:n] ++ // After the "-----" of the ending line, there should be the same type ++ // and then a final five dashes. ++ endTrailer := rest[endTrailerIndex:] ++ endTrailerLen := len(typeLine) + len(pemEndOfLine) ++ if len(endTrailer) < endTrailerLen { ++ continue ++ } ++ ++ restOfEndLine := endTrailer[endTrailerLen:] ++ endTrailer = endTrailer[:endTrailerLen] ++ if !bytes.HasPrefix(endTrailer, typeLine) || ++ !bytes.HasSuffix(endTrailer, pemEndOfLine) { ++ continue ++ } + +- // the -1 is because we might have only matched pemEnd without the +- // leading newline if the PEM block was empty. +- _, rest = getLine(rest[endIndex+len(pemEnd)-1:]) ++ // The line must end with only whitespace. ++ if s, _ := getLine(restOfEndLine); len(s) != 0 { ++ continue ++ } + +- return +-} ++ base64Data := removeSpacesAndTabs(rest[:endIndex]) ++ p.Bytes = make([]byte, base64.StdEncoding.DecodedLen(len(base64Data))) ++ n, err := base64.StdEncoding.Decode(p.Bytes, base64Data) ++ if err != nil { ++ continue ++ } ++ p.Bytes = p.Bytes[:n] + +-func decodeError(data, rest []byte) (*Block, []byte) { +- // If we get here then we have rejected a likely looking, but +- // ultimately invalid PEM block. We need to start over from a new +- // position. We have consumed the preamble line and will have consumed +- // any lines which could be header lines. However, a valid preamble +- // line is not a valid header line, therefore we cannot have consumed +- // the preamble line for the any subsequent block. Thus, we will always +- // find any valid block, no matter what bytes precede it. +- // +- // For example, if the input is +- // +- // -----BEGIN MALFORMED BLOCK----- +- // junk that may look like header lines +- // or data lines, but no END line +- // +- // -----BEGIN ACTUAL BLOCK----- +- // realdata +- // -----END ACTUAL BLOCK----- +- // +- // we've failed to parse using the first BEGIN line +- // and now will try again, using the second BEGIN line. +- p, rest := Decode(rest) +- if p == nil { +- rest = data ++ // the -1 is because we might have only matched pemEnd without the ++ // leading newline if the PEM block was empty. ++ _, rest = getLine(rest[endIndex+len(pemEnd)-1:]) ++ return p, rest + } +- return p, rest + } + + const pemLineLength = 64 +diff --git a/src/encoding/pem/pem_test.go b/src/encoding/pem/pem_test.go +index b2b6b15e73..c94b5ca53b 100644 +--- a/src/encoding/pem/pem_test.go ++++ b/src/encoding/pem/pem_test.go +@@ -107,6 +107,12 @@ const pemMissingEndingSpace = ` + dGVzdA== + -----ENDBAR-----` + ++const pemMissingEndLine = ` ++-----BEGIN FOO----- ++Header: 1` ++ ++var pemRepeatingBegin = strings.Repeat("-----BEGIN \n", 10) ++ + var badPEMTests = []struct { + name string + input string +@@ -131,14 +137,34 @@ var badPEMTests = []struct { + "missing ending space", + pemMissingEndingSpace, + }, ++ { ++ "repeating begin", ++ pemRepeatingBegin, ++ }, ++ { ++ "missing end line", ++ pemMissingEndLine, ++ }, + } + + func TestBadDecode(t *testing.T) { + for _, test := range badPEMTests { +- result, _ := Decode([]byte(test.input)) ++ result, rest := Decode([]byte(test.input)) + if result != nil { + t.Errorf("unexpected success while parsing %q", test.name) + } ++ if string(rest) != test.input { ++ t.Errorf("unexpected rest: %q; want = %q", rest, test.input) ++ } ++ } ++} ++ ++func TestCVE202224675(t *testing.T) { ++ // Prior to CVE-2022-24675, this input would cause a stack overflow. ++ input := []byte(strings.Repeat("-----BEGIN \n", 10000000)) ++ result, rest := Decode(input) ++ if result != nil || !reflect.DeepEqual(rest, input) { ++ t.Errorf("Encode of %#v decoded as %#v", input, rest) + } + } + +-- +2.30.0 + diff --git a/0003-release-branch.go1.17-syscall-fix-ForkLock-spurious-.patch b/0003-release-branch.go1.17-syscall-fix-ForkLock-spurious-.patch new file mode 100644 index 0000000000000000000000000000000000000000..64aee693f6998b6f9dd75f404673a048b9e74a24 --- /dev/null +++ b/0003-release-branch.go1.17-syscall-fix-ForkLock-spurious-.patch @@ -0,0 +1,79 @@ +From e7aab832069d06d77e04a585803dfdb04453253a Mon Sep 17 00:00:00 2001 +From: Russ Cox +Date: Wed, 8 Dec 2021 18:05:11 -0500 +Subject: [PATCH] [release-branch.go1.17] syscall: fix ForkLock spurious + close(0) on pipe failure + +Pipe (and therefore forkLockPipe) does not make any guarantees +about the state of p after a failed Pipe(p). Avoid that assumption +and the too-clever goto, so that we don't accidentally Close a real fd +if the failed pipe leaves p[0] or p[1] set >= 0. + +Updates #50057 +Fixes CVE-2021-44717 + +Change-Id: Iff8e19a6efbba0c73cc8b13ecfae381c87600bb4 +Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1291270 +Reviewed-by: Ian Lance Taylor +Reviewed-on: https://go-review.googlesource.com/c/go/+/370534 +Trust: Filippo Valsorda +Run-TryBot: Filippo Valsorda +TryBot-Result: Gopher Robot +Reviewed-by: Alex Rakoczy +--- + src/syscall/exec_unix.go | 20 ++++++-------------- + 1 file changed, 6 insertions(+), 14 deletions(-) + +diff --git a/src/syscall/exec_unix.go b/src/syscall/exec_unix.go +index 54b18dccd7..c9c9d1abf3 100644 +--- a/src/syscall/exec_unix.go ++++ b/src/syscall/exec_unix.go +@@ -153,9 +153,6 @@ func forkExec(argv0 string, argv []string, attr *ProcAttr) (pid int, err error) + sys = &zeroSysProcAttr + } + +- p[0] = -1 +- p[1] = -1 +- + // Convert args to C form. + argv0p, err := BytePtrFromString(argv0) + if err != nil { +@@ -205,14 +202,17 @@ func forkExec(argv0 string, argv []string, attr *ProcAttr) (pid int, err error) + + // Allocate child status pipe close on exec. + if err = forkExecPipe(p[:]); err != nil { +- goto error ++ ForkLock.Unlock() ++ return 0, err + } + + // Kick off child. + pid, err1 = forkAndExecInChild(argv0p, argvp, envvp, chroot, dir, attr, sys, p[1]) + if err1 != 0 { +- err = Errno(err1) +- goto error ++ Close(p[0]) ++ Close(p[1]) ++ ForkLock.Unlock() ++ return 0, Errno(err1) + } + ForkLock.Unlock() + +@@ -244,14 +244,6 @@ func forkExec(argv0 string, argv []string, attr *ProcAttr) (pid int, err error) + + // Read got EOF, so pipe closed on exec, so exec succeeded. + return pid, nil +- +-error: +- if p[0] >= 0 { +- Close(p[0]) +- Close(p[1]) +- } +- ForkLock.Unlock() +- return 0, err + } + + // Combination of fork and exec, careful to be thread safe. +-- +2.30.0 + diff --git a/0004-backport-cmd-link-mark-unexported-methods-for-plugins.patch b/0004-backport-cmd-link-mark-unexported-methods-for-plugins.patch new file mode 100644 index 0000000000000000000000000000000000000000..6b9dd4b07c525c5e2263c1abb1c7c8fa199f8c92 --- /dev/null +++ b/0004-backport-cmd-link-mark-unexported-methods-for-plugins.patch @@ -0,0 +1,39 @@ +From c872b0594f716a2a0799b07d7226a45f02c005f1 Mon Sep 17 00:00:00 2001 +From: Cherry Mui +Date: Wed, 16 Mar 2022 13:07:57 -0400 +Subject: [PATCH] cmd/link: mark unexported methods for plugins + +When plugin is used, we already mark all exported methods +reachable. However, when the plugin and the host program share +a common package, an unexported method could also be reachable +from both the plugin and the host via interfaces. We need to mark +them as well. + +Fixes #51621. + +Change-Id: I1a70d3f96b66b803f2d0ab14d00ed0df276ea500 +Reviewed-on: https://go-review.googlesource.com/c/go/+/393365 +Trust: Cherry Mui +Run-TryBot: Cherry Mui +TryBot-Result: Gopher Robot +Reviewed-by: Than McIntosh +--- + src/cmd/link/internal/ld/deadcode.go | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/src/cmd/link/internal/ld/deadcode.go b/src/cmd/link/internal/ld/deadcode.go +index e4fa75f..21a9703 100644 +--- a/src/cmd/link/internal/ld/deadcode.go ++++ b/src/cmd/link/internal/ld/deadcode.go +@@ -350,7 +350,7 @@ func deadcode(ctxt *Link) { + // in the last pass. + rem := d.markableMethods[:0] + for _, m := range d.markableMethods { +- if (d.reflectSeen && m.isExported()) || d.ifaceMethod[m.m] { ++ if (d.reflectSeen && (m.isExported() || d.dynlink)) || d.ifaceMethod[m.m] { + d.markMethod(m) + } else { + rem = append(rem, m) +-- +1.8.3.1 + diff --git a/0005-release-branch.go1.17-net-http-preserve-nil-values-i.patch b/0005-release-branch.go1.17-net-http-preserve-nil-values-i.patch new file mode 100644 index 0000000000000000000000000000000000000000..98972340a918d866c0322d17b1c10068f2f57910 --- /dev/null +++ b/0005-release-branch.go1.17-net-http-preserve-nil-values-i.patch @@ -0,0 +1,70 @@ +From 67bff2eb995a098f838fa4b799c0b8261292e6e7 Mon Sep 17 00:00:00 2001 +From: Damien Neil +Date: Fri, 17 Jun 2022 10:09:45 -0700 +Subject: [PATCH 01/11] [release-branch.go1.17] net/http: preserve nil values + in Header.Clone + +ReverseProxy makes a distinction between nil and zero-length header values. +Avoid losing nil-ness when cloning a request. + +Thanks to Christian Mehlmauer for discovering this. + +For #53423 +For CVE-2022-32148 +Fixes #53620 + +Change-Id: Ice369cdb4712e2d62e25bb881b080847aa4801f5 +Reviewed-on: https://go-review.googlesource.com/c/go/+/412857 +Reviewed-by: Ian Lance Taylor +Reviewed-by: Brad Fitzpatrick +(cherry picked from commit b2cc0fecc2ccd80e6d5d16542cc684f97b3a9c8a) +Reviewed-on: https://go-review.googlesource.com/c/go/+/415221 +Reviewed-by: Heschi Kreinick +TryBot-Result: Gopher Robot +Run-TryBot: Michael Knyszek +Run-TryBot: Heschi Kreinick +Reviewed-by: Michael Knyszek + +Conflict: NA +Reference: https://go-review.googlesource.com/c/go/+/415221 +--- + src/net/http/header.go | 6 ++++++ + src/net/http/header_test.go | 5 +++++ + 2 files changed, 11 insertions(+) + +diff --git a/src/net/http/header.go b/src/net/http/header.go +index 4c72dcb2c88..ef4ee7ffa81 100644 +--- a/src/net/http/header.go ++++ b/src/net/http/header.go +@@ -101,6 +101,12 @@ func (h Header) Clone() Header { + sv := make([]string, nv) // shared backing array for headers' values + h2 := make(Header, len(h)) + for k, vv := range h { ++ if vv == nil { ++ // Preserve nil values. ReverseProxy distinguishes ++ // between nil and zero-length header values. ++ h2[k] = nil ++ continue ++ } + n := copy(sv, vv) + h2[k] = sv[:n:n] + sv = sv[n:] +diff --git a/src/net/http/header_test.go b/src/net/http/header_test.go +index 47893629194..80c003551db 100644 +--- a/src/net/http/header_test.go ++++ b/src/net/http/header_test.go +@@ -235,6 +235,11 @@ func TestCloneOrMakeHeader(t *testing.T) { + in: Header{"foo": {"bar"}}, + want: Header{"foo": {"bar"}}, + }, ++ { ++ name: "nil value", ++ in: Header{"foo": nil}, ++ want: Header{"foo": nil}, ++ }, + } + + for _, tt := range tests { +-- +2.30.2 + diff --git a/0006-release-branch.go1.17-go-parser-limit-recursion-dept.patch b/0006-release-branch.go1.17-go-parser-limit-recursion-dept.patch new file mode 100644 index 0000000000000000000000000000000000000000..23a903a9e5c421b420127404315fbf9983f6fde8 --- /dev/null +++ b/0006-release-branch.go1.17-go-parser-limit-recursion-dept.patch @@ -0,0 +1,421 @@ +From b78e521644334294019da243a5ff57436f70cd72 Mon Sep 17 00:00:00 2001 +From: Roland Shoemaker +Date: Wed, 15 Jun 2022 10:43:05 -0700 +Subject: [PATCH 02/11] [release-branch.go1.17] go/parser: limit recursion + depth + +Limit nested parsing to 100,000, which prevents stack exhaustion when +parsing deeply nested statements, types, and expressions. Also limit +the scope depth to 1,000 during object resolution. + +Thanks to Juho Nurminen of Mattermost for reporting this issue. + +Fixes #53707 +Updates #53616 +Fixes CVE-2022-1962 + +Change-Id: I4d7b86c1d75d0bf3c7af1fdea91582aa74272c64 +Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1491025 +Reviewed-by: Russ Cox +Reviewed-by: Damien Neil +(cherry picked from commit 6a856f08d58e4b6705c0c337d461c540c1235c83) +Reviewed-on: https://go-review.googlesource.com/c/go/+/417070 +Reviewed-by: Heschi Kreinick +TryBot-Result: Gopher Robot +Run-TryBot: Michael Knyszek + +Conflict: NA +Reference: https://go-review.googlesource.com/c/go/+/417070 +--- + src/go/parser/interface.go | 10 ++- + src/go/parser/parser.go | 54 ++++++++++- + src/go/parser/parser_test.go | 169 +++++++++++++++++++++++++++++++++++ + src/go/parser/resolver.go | 9 ++ + 4 files changed, 236 insertions(+), 6 deletions(-) + +diff --git a/src/go/parser/interface.go b/src/go/parser/interface.go +index 85486d2f4b4..eae429e6ef3 100644 +--- a/src/go/parser/interface.go ++++ b/src/go/parser/interface.go +@@ -97,8 +97,11 @@ func ParseFile(fset *token.FileSet, filename string, src interface{}, mode Mode) + defer func() { + if e := recover(); e != nil { + // resume same panic if it's not a bailout +- if _, ok := e.(bailout); !ok { ++ bail, ok := e.(bailout) ++ if !ok { + panic(e) ++ } else if bail.msg != "" { ++ p.errors.Add(p.file.Position(bail.pos), bail.msg) + } + } + +@@ -203,8 +206,11 @@ func ParseExprFrom(fset *token.FileSet, filename string, src interface{}, mode M + defer func() { + if e := recover(); e != nil { + // resume same panic if it's not a bailout +- if _, ok := e.(bailout); !ok { ++ bail, ok := e.(bailout) ++ if !ok { + panic(e) ++ } else if bail.msg != "" { ++ p.errors.Add(p.file.Position(bail.pos), bail.msg) + } + } + p.errors.Sort() +diff --git a/src/go/parser/parser.go b/src/go/parser/parser.go +index f10c8650afd..2c42b9f8cc2 100644 +--- a/src/go/parser/parser.go ++++ b/src/go/parser/parser.go +@@ -60,6 +60,10 @@ type parser struct { + inRhs bool // if set, the parser is parsing a rhs expression + + imports []*ast.ImportSpec // list of imports ++ ++ // nestLev is used to track and limit the recursion depth ++ // during parsing. ++ nestLev int + } + + func (p *parser) init(fset *token.FileSet, filename string, src []byte, mode Mode) { +@@ -110,6 +114,24 @@ func un(p *parser) { + p.printTrace(")") + } + ++// maxNestLev is the deepest we're willing to recurse during parsing ++const maxNestLev int = 1e5 ++ ++func incNestLev(p *parser) *parser { ++ p.nestLev++ ++ if p.nestLev > maxNestLev { ++ p.error(p.pos, "exceeded max nesting depth") ++ panic(bailout{}) ++ } ++ return p ++} ++ ++// decNestLev is used to track nesting depth during parsing to prevent stack exhaustion. ++// It is used along with incNestLev in a similar fashion to how un and trace are used. ++func decNestLev(p *parser) { ++ p.nestLev-- ++} ++ + // Advance to the next token. + func (p *parser) next0() { + // Because of one-token look-ahead, print the previous token +@@ -222,8 +244,12 @@ func (p *parser) next() { + } + } + +-// A bailout panic is raised to indicate early termination. +-type bailout struct{} ++// A bailout panic is raised to indicate early termination. pos and msg are ++// only populated when bailing out of object resolution. ++type bailout struct { ++ pos token.Pos ++ msg string ++} + + func (p *parser) error(pos token.Pos, msg string) { + if p.trace { +@@ -1119,6 +1145,8 @@ func (p *parser) parseTypeInstance(typ ast.Expr) ast.Expr { + } + + func (p *parser) tryIdentOrType() ast.Expr { ++ defer decNestLev(incNestLev(p)) ++ + switch p.tok { + case token.IDENT: + typ := p.parseTypeName(nil) +@@ -1531,7 +1559,13 @@ func (p *parser) parsePrimaryExpr() (x ast.Expr) { + } + + x = p.parseOperand() +- for { ++ // We track the nesting here rather than at the entry for the function, ++ // since it can iteratively produce a nested output, and we want to ++ // limit how deep a structure we generate. ++ var n int ++ defer func() { p.nestLev -= n }() ++ for n = 1; ; n++ { ++ incNestLev(p) + switch p.tok { + case token.PERIOD: + p.next() +@@ -1591,6 +1625,8 @@ func (p *parser) parsePrimaryExpr() (x ast.Expr) { + } + + func (p *parser) parseUnaryExpr() ast.Expr { ++ defer decNestLev(incNestLev(p)) ++ + if p.trace { + defer un(trace(p, "UnaryExpr")) + } +@@ -1673,7 +1709,13 @@ func (p *parser) parseBinaryExpr(prec1 int) ast.Expr { + } + + x := p.parseUnaryExpr() +- for { ++ // We track the nesting here rather than at the entry for the function, ++ // since it can iteratively produce a nested output, and we want to ++ // limit how deep a structure we generate. ++ var n int ++ defer func() { p.nestLev -= n }() ++ for n = 1; ; n++ { ++ incNestLev(p) + op, oprec := p.tokPrec() + if oprec < prec1 { + return x +@@ -1962,6 +2004,8 @@ func (p *parser) parseIfHeader() (init ast.Stmt, cond ast.Expr) { + } + + func (p *parser) parseIfStmt() *ast.IfStmt { ++ defer decNestLev(incNestLev(p)) ++ + if p.trace { + defer un(trace(p, "IfStmt")) + } +@@ -2265,6 +2309,8 @@ func (p *parser) parseForStmt() ast.Stmt { + } + + func (p *parser) parseStmt() (s ast.Stmt) { ++ defer decNestLev(incNestLev(p)) ++ + if p.trace { + defer un(trace(p, "Statement")) + } +diff --git a/src/go/parser/parser_test.go b/src/go/parser/parser_test.go +index a4f882d3688..1a46c878663 100644 +--- a/src/go/parser/parser_test.go ++++ b/src/go/parser/parser_test.go +@@ -10,6 +10,7 @@ import ( + "go/ast" + "go/token" + "io/fs" ++ "runtime" + "strings" + "testing" + ) +@@ -577,3 +578,171 @@ type x int // comment + t.Errorf("got %q, want %q", comment, "// comment") + } + } ++ ++var parseDepthTests = []struct { ++ name string ++ format string ++ // multipler is used when a single statement may result in more than one ++ // change in the depth level, for instance "1+(..." produces a BinaryExpr ++ // followed by a UnaryExpr, which increments the depth twice. The test ++ // case comment explains which nodes are triggering the multiple depth ++ // changes. ++ parseMultiplier int ++ // scope is true if we should also test the statement for the resolver scope ++ // depth limit. ++ scope bool ++ // scopeMultiplier does the same as parseMultiplier, but for the scope ++ // depths. ++ scopeMultiplier int ++}{ ++ // The format expands the part inside « » many times. ++ // A second set of brackets nested inside the first stops the repetition, ++ // so that for example «(«1»)» expands to (((...((((1))))...))). ++ {name: "array", format: "package main; var x «[1]»int"}, ++ {name: "slice", format: "package main; var x «[]»int"}, ++ {name: "struct", format: "package main; var x «struct { X «int» }»", scope: true}, ++ {name: "pointer", format: "package main; var x «*»int"}, ++ {name: "func", format: "package main; var x «func()»int", scope: true}, ++ {name: "chan", format: "package main; var x «chan »int"}, ++ {name: "chan2", format: "package main; var x «<-chan »int"}, ++ {name: "interface", format: "package main; var x «interface { M() «int» }»", scope: true, scopeMultiplier: 2}, // Scopes: InterfaceType, FuncType ++ {name: "map", format: "package main; var x «map[int]»int"}, ++ {name: "slicelit", format: "package main; var x = «[]any{«»}»", parseMultiplier: 2}, // Parser nodes: UnaryExpr, CompositeLit ++ {name: "arraylit", format: "package main; var x = «[1]any{«nil»}»", parseMultiplier: 2}, // Parser nodes: UnaryExpr, CompositeLit ++ {name: "structlit", format: "package main; var x = «struct{x any}{«nil»}»", parseMultiplier: 2}, // Parser nodes: UnaryExpr, CompositeLit ++ {name: "maplit", format: "package main; var x = «map[int]any{1:«nil»}»", parseMultiplier: 2}, // Parser nodes: CompositeLit, KeyValueExpr ++ {name: "dot", format: "package main; var x = «x.»x"}, ++ {name: "index", format: "package main; var x = x«[1]»"}, ++ {name: "slice", format: "package main; var x = x«[1:2]»"}, ++ {name: "slice3", format: "package main; var x = x«[1:2:3]»"}, ++ {name: "dottype", format: "package main; var x = x«.(any)»"}, ++ {name: "callseq", format: "package main; var x = x«()»"}, ++ {name: "methseq", format: "package main; var x = x«.m()»", parseMultiplier: 2}, // Parser nodes: SelectorExpr, CallExpr ++ {name: "binary", format: "package main; var x = «1+»1"}, ++ {name: "binaryparen", format: "package main; var x = «1+(«1»)»", parseMultiplier: 2}, // Parser nodes: BinaryExpr, ParenExpr ++ {name: "unary", format: "package main; var x = «^»1"}, ++ {name: "addr", format: "package main; var x = «& »x"}, ++ {name: "star", format: "package main; var x = «*»x"}, ++ {name: "recv", format: "package main; var x = «<-»x"}, ++ {name: "call", format: "package main; var x = «f(«1»)»", parseMultiplier: 2}, // Parser nodes: Ident, CallExpr ++ {name: "conv", format: "package main; var x = «(*T)(«1»)»", parseMultiplier: 2}, // Parser nodes: ParenExpr, CallExpr ++ {name: "label", format: "package main; func main() { «Label:» }"}, ++ {name: "if", format: "package main; func main() { «if true { «» }»}", parseMultiplier: 2, scope: true, scopeMultiplier: 2}, // Parser nodes: IfStmt, BlockStmt. Scopes: IfStmt, BlockStmt ++ {name: "ifelse", format: "package main; func main() { «if true {} else » {} }", scope: true}, ++ {name: "switch", format: "package main; func main() { «switch { default: «» }»}", scope: true, scopeMultiplier: 2}, // Scopes: TypeSwitchStmt, CaseClause ++ {name: "typeswitch", format: "package main; func main() { «switch x.(type) { default: «» }» }", scope: true, scopeMultiplier: 2}, // Scopes: TypeSwitchStmt, CaseClause ++ {name: "for0", format: "package main; func main() { «for { «» }» }", scope: true, scopeMultiplier: 2}, // Scopes: ForStmt, BlockStmt ++ {name: "for1", format: "package main; func main() { «for x { «» }» }", scope: true, scopeMultiplier: 2}, // Scopes: ForStmt, BlockStmt ++ {name: "for3", format: "package main; func main() { «for f(); g(); h() { «» }» }", scope: true, scopeMultiplier: 2}, // Scopes: ForStmt, BlockStmt ++ {name: "forrange0", format: "package main; func main() { «for range x { «» }» }", scope: true, scopeMultiplier: 2}, // Scopes: RangeStmt, BlockStmt ++ {name: "forrange1", format: "package main; func main() { «for x = range z { «» }» }", scope: true, scopeMultiplier: 2}, // Scopes: RangeStmt, BlockStmt ++ {name: "forrange2", format: "package main; func main() { «for x, y = range z { «» }» }", scope: true, scopeMultiplier: 2}, // Scopes: RangeStmt, BlockStmt ++ {name: "go", format: "package main; func main() { «go func() { «» }()» }", parseMultiplier: 2, scope: true}, // Parser nodes: GoStmt, FuncLit ++ {name: "defer", format: "package main; func main() { «defer func() { «» }()» }", parseMultiplier: 2, scope: true}, // Parser nodes: DeferStmt, FuncLit ++ {name: "select", format: "package main; func main() { «select { default: «» }» }", scope: true}, ++} ++ ++// split splits pre«mid»post into pre, mid, post. ++// If the string does not have that form, split returns x, "", "". ++func split(x string) (pre, mid, post string) { ++ start, end := strings.Index(x, "«"), strings.LastIndex(x, "»") ++ if start < 0 || end < 0 { ++ return x, "", "" ++ } ++ return x[:start], x[start+len("«") : end], x[end+len("»"):] ++} ++ ++func TestParseDepthLimit(t *testing.T) { ++ if runtime.GOARCH == "wasm" { ++ t.Skip("causes call stack exhaustion on js/wasm") ++ } ++ for _, tt := range parseDepthTests { ++ for _, size := range []string{"small", "big"} { ++ t.Run(tt.name+"/"+size, func(t *testing.T) { ++ n := maxNestLev + 1 ++ if tt.parseMultiplier > 0 { ++ n /= tt.parseMultiplier ++ } ++ if size == "small" { ++ // Decrease the number of statements by 10, in order to check ++ // that we do not fail when under the limit. 10 is used to ++ // provide some wiggle room for cases where the surrounding ++ // scaffolding syntax adds some noise to the depth that changes ++ // on a per testcase basis. ++ n -= 10 ++ } ++ ++ pre, mid, post := split(tt.format) ++ if strings.Contains(mid, "«") { ++ left, base, right := split(mid) ++ mid = strings.Repeat(left, n) + base + strings.Repeat(right, n) ++ } else { ++ mid = strings.Repeat(mid, n) ++ } ++ input := pre + mid + post ++ ++ fset := token.NewFileSet() ++ _, err := ParseFile(fset, "", input, ParseComments|SkipObjectResolution) ++ if size == "small" { ++ if err != nil { ++ t.Errorf("ParseFile(...): %v (want success)", err) ++ } ++ } else { ++ expected := "exceeded max nesting depth" ++ if err == nil || !strings.HasSuffix(err.Error(), expected) { ++ t.Errorf("ParseFile(...) = _, %v, want %q", err, expected) ++ } ++ } ++ }) ++ } ++ } ++} ++ ++func TestScopeDepthLimit(t *testing.T) { ++ if runtime.GOARCH == "wasm" { ++ t.Skip("causes call stack exhaustion on js/wasm") ++ } ++ for _, tt := range parseDepthTests { ++ if !tt.scope { ++ continue ++ } ++ for _, size := range []string{"small", "big"} { ++ t.Run(tt.name+"/"+size, func(t *testing.T) { ++ n := maxScopeDepth + 1 ++ if tt.scopeMultiplier > 0 { ++ n /= tt.scopeMultiplier ++ } ++ if size == "small" { ++ // Decrease the number of statements by 10, in order to check ++ // that we do not fail when under the limit. 10 is used to ++ // provide some wiggle room for cases where the surrounding ++ // scaffolding syntax adds some noise to the depth that changes ++ // on a per testcase basis. ++ n -= 10 ++ } ++ ++ pre, mid, post := split(tt.format) ++ if strings.Contains(mid, "«") { ++ left, base, right := split(mid) ++ mid = strings.Repeat(left, n) + base + strings.Repeat(right, n) ++ } else { ++ mid = strings.Repeat(mid, n) ++ } ++ input := pre + mid + post ++ ++ fset := token.NewFileSet() ++ _, err := ParseFile(fset, "", input, DeclarationErrors) ++ if size == "small" { ++ if err != nil { ++ t.Errorf("ParseFile(...): %v (want success)", err) ++ } ++ } else { ++ expected := "exceeded max scope depth during object resolution" ++ if err == nil || !strings.HasSuffix(err.Error(), expected) { ++ t.Errorf("ParseFile(...) = _, %v, want %q", err, expected) ++ } ++ } ++ }) ++ } ++ } ++} +diff --git a/src/go/parser/resolver.go b/src/go/parser/resolver.go +index cf92c7e4f57..f55bdb7f177 100644 +--- a/src/go/parser/resolver.go ++++ b/src/go/parser/resolver.go +@@ -25,6 +25,7 @@ func resolveFile(file *ast.File, handle *token.File, declErr func(token.Pos, str + declErr: declErr, + topScope: pkgScope, + pkgScope: pkgScope, ++ depth: 1, + } + + for _, decl := range file.Decls { +@@ -53,6 +54,8 @@ func resolveFile(file *ast.File, handle *token.File, declErr func(token.Pos, str + file.Unresolved = r.unresolved[0:i] + } + ++const maxScopeDepth int = 1e3 ++ + type resolver struct { + handle *token.File + declErr func(token.Pos, string) +@@ -61,6 +64,7 @@ type resolver struct { + pkgScope *ast.Scope // pkgScope.Outer == nil + topScope *ast.Scope // top-most scope; may be pkgScope + unresolved []*ast.Ident // unresolved identifiers ++ depth int // scope depth + + // Label scopes + // (maintained by open/close LabelScope) +@@ -83,6 +87,10 @@ func (r *resolver) sprintf(format string, args ...interface{}) string { + } + + func (r *resolver) openScope(pos token.Pos) { ++ r.depth++ ++ if r.depth > maxScopeDepth { ++ panic(bailout{pos: pos, msg: "exceeded max scope depth during object resolution"}) ++ } + if debugResolve { + r.dump("opening scope @%v", pos) + } +@@ -90,6 +98,7 @@ func (r *resolver) openScope(pos token.Pos) { + } + + func (r *resolver) closeScope() { ++ r.depth-- + if debugResolve { + r.dump("closing scope") + } +-- +2.30.2 + diff --git a/0007-release-branch.go1.17-net-http-don-t-strip-whitespac.patch b/0007-release-branch.go1.17-net-http-don-t-strip-whitespac.patch new file mode 100644 index 0000000000000000000000000000000000000000..7fdcd6f86e68031ece6523d3aed9973202e91630 --- /dev/null +++ b/0007-release-branch.go1.17-net-http-don-t-strip-whitespac.patch @@ -0,0 +1,62 @@ +From 4ad62aecaf57ca3adc11a04bd2113bdbee6249c3 Mon Sep 17 00:00:00 2001 +From: Damien Neil +Date: Wed, 1 Jun 2022 11:17:07 -0700 +Subject: [PATCH 03/11] [release-branch.go1.17] net/http: don't strip + whitespace from Transfer-Encoding headers + +Do not accept "Transfer-Encoding: \rchunked" as a valid TE header +setting chunked encoding. + +Thanks to Zeyu Zhang (https://www.zeyu2001.com/) for identifying +the issue. + +For #53188 +For CVE-2022-1705 +Fixes #53432 + +Change-Id: I1a16631425159267f2eca68056b057192a7edf6c +Reviewed-on: https://go-review.googlesource.com/c/go/+/409874 +Reviewed-by: Roland Shoemaker +Reviewed-by: Brad Fitzpatrick +(cherry picked from commit e5017a93fcde94f09836200bca55324af037ee5f) +Reviewed-on: https://go-review.googlesource.com/c/go/+/415217 +Reviewed-by: Dmitri Shuralyov +Run-TryBot: Dmitri Shuralyov +Reviewed-by: Dmitri Shuralyov +TryBot-Result: Gopher Robot + +Conflict: NA +Reference: https://go-review.googlesource.com/c/go/+/415217 +--- + src/net/http/serve_test.go | 1 + + src/net/http/transfer.go | 2 +- + 2 files changed, 2 insertions(+), 1 deletion(-) + +diff --git a/src/net/http/serve_test.go b/src/net/http/serve_test.go +index 6394da3bb7c..bfac783e3a9 100644 +--- a/src/net/http/serve_test.go ++++ b/src/net/http/serve_test.go +@@ -6189,6 +6189,7 @@ func TestUnsupportedTransferEncodingsReturn501(t *testing.T) { + "fugazi", + "foo-bar", + "unknown", ++ "\rchunked", + } + + for _, badTE := range unsupportedTEs { +diff --git a/src/net/http/transfer.go b/src/net/http/transfer.go +index 85c2e5a360d..3894007d306 100644 +--- a/src/net/http/transfer.go ++++ b/src/net/http/transfer.go +@@ -639,7 +639,7 @@ func (t *transferReader) parseTransferEncoding() error { + if len(raw) != 1 { + return &unsupportedTEError{fmt.Sprintf("too many transfer encodings: %q", raw)} + } +- if !ascii.EqualFold(textproto.TrimString(raw[0]), "chunked") { ++ if !ascii.EqualFold(raw[0], "chunked") { + return &unsupportedTEError{fmt.Sprintf("unsupported transfer encoding: %q", raw[0])} + } + +-- +2.30.2 + diff --git a/0008-release-branch.go1.17-encoding-xml-limit-depth-of-ne.patch b/0008-release-branch.go1.17-encoding-xml-limit-depth-of-ne.patch new file mode 100644 index 0000000000000000000000000000000000000000..077af1523521e89770af7211afd05a3cf1422ca7 --- /dev/null +++ b/0008-release-branch.go1.17-encoding-xml-limit-depth-of-ne.patch @@ -0,0 +1,168 @@ +From 106c859f68c3137cfa05c433a9b90494db386fda Mon Sep 17 00:00:00 2001 +From: Roland Shoemaker +Date: Tue, 29 Mar 2022 15:52:09 -0700 +Subject: [PATCH 04/11] [release-branch.go1.17] encoding/xml: limit depth of + nesting in unmarshal + +Prevent exhausting the stack limit when unmarshalling extremely deeply +nested structures into nested types. + +Fixes #53715 +Updates #53611 +Fixes CVE-2022-30633 + +Change-Id: Ic6c5d41674c93cfc9a316135a408db9156d39c59 +Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1421319 +Reviewed-by: Damien Neil +Reviewed-by: Julie Qiu +(cherry picked from commit ebee00a55e28931b2cad0e76207a73712b000432) +Reviewed-on: https://go-review.googlesource.com/c/go/+/417069 +Reviewed-by: Heschi Kreinick +Run-TryBot: Michael Knyszek +TryBot-Result: Gopher Robot + +Conflict: NA +Reference: https://go-review.googlesource.com/c/go/+/417069 +--- + src/encoding/xml/read.go | 27 +++++++++++++++++++-------- + src/encoding/xml/read_test.go | 32 ++++++++++++++++++++++++++++++++ + 2 files changed, 51 insertions(+), 8 deletions(-) + +diff --git a/src/encoding/xml/read.go b/src/encoding/xml/read.go +index ef5df3f7f6a..e0ed8b527ce 100644 +--- a/src/encoding/xml/read.go ++++ b/src/encoding/xml/read.go +@@ -148,7 +148,7 @@ func (d *Decoder) DecodeElement(v interface{}, start *StartElement) error { + if val.Kind() != reflect.Ptr { + return errors.New("non-pointer passed to Unmarshal") + } +- return d.unmarshal(val.Elem(), start) ++ return d.unmarshal(val.Elem(), start, 0) + } + + // An UnmarshalError represents an error in the unmarshaling process. +@@ -304,8 +304,15 @@ var ( + textUnmarshalerType = reflect.TypeOf((*encoding.TextUnmarshaler)(nil)).Elem() + ) + ++const maxUnmarshalDepth = 10000 ++ ++var errExeceededMaxUnmarshalDepth = errors.New("exceeded max depth") ++ + // Unmarshal a single XML element into val. +-func (d *Decoder) unmarshal(val reflect.Value, start *StartElement) error { ++func (d *Decoder) unmarshal(val reflect.Value, start *StartElement, depth int) error { ++ if depth >= maxUnmarshalDepth { ++ return errExeceededMaxUnmarshalDepth ++ } + // Find start element if we need it. + if start == nil { + for { +@@ -398,7 +405,7 @@ func (d *Decoder) unmarshal(val reflect.Value, start *StartElement) error { + v.Set(reflect.Append(val, reflect.Zero(v.Type().Elem()))) + + // Recur to read element into slice. +- if err := d.unmarshal(v.Index(n), start); err != nil { ++ if err := d.unmarshal(v.Index(n), start, depth+1); err != nil { + v.SetLen(n) + return err + } +@@ -521,13 +528,15 @@ Loop: + case StartElement: + consumed := false + if sv.IsValid() { +- consumed, err = d.unmarshalPath(tinfo, sv, nil, &t) ++ // unmarshalPath can call unmarshal, so we need to pass the depth through so that ++ // we can continue to enforce the maximum recusion limit. ++ consumed, err = d.unmarshalPath(tinfo, sv, nil, &t, depth) + if err != nil { + return err + } + if !consumed && saveAny.IsValid() { + consumed = true +- if err := d.unmarshal(saveAny, &t); err != nil { ++ if err := d.unmarshal(saveAny, &t, depth+1); err != nil { + return err + } + } +@@ -672,7 +681,7 @@ func copyValue(dst reflect.Value, src []byte) (err error) { + // The consumed result tells whether XML elements have been consumed + // from the Decoder until start's matching end element, or if it's + // still untouched because start is uninteresting for sv's fields. +-func (d *Decoder) unmarshalPath(tinfo *typeInfo, sv reflect.Value, parents []string, start *StartElement) (consumed bool, err error) { ++func (d *Decoder) unmarshalPath(tinfo *typeInfo, sv reflect.Value, parents []string, start *StartElement, depth int) (consumed bool, err error) { + recurse := false + Loop: + for i := range tinfo.fields { +@@ -687,7 +696,7 @@ Loop: + } + if len(finfo.parents) == len(parents) && finfo.name == start.Name.Local { + // It's a perfect match, unmarshal the field. +- return true, d.unmarshal(finfo.value(sv, initNilPointers), start) ++ return true, d.unmarshal(finfo.value(sv, initNilPointers), start, depth+1) + } + if len(finfo.parents) > len(parents) && finfo.parents[len(parents)] == start.Name.Local { + // It's a prefix for the field. Break and recurse +@@ -716,7 +725,9 @@ Loop: + } + switch t := tok.(type) { + case StartElement: +- consumed2, err := d.unmarshalPath(tinfo, sv, parents, &t) ++ // the recursion depth of unmarshalPath is limited to the path length specified ++ // by the struct field tag, so we don't increment the depth here. ++ consumed2, err := d.unmarshalPath(tinfo, sv, parents, &t, depth) + if err != nil { + return true, err + } +diff --git a/src/encoding/xml/read_test.go b/src/encoding/xml/read_test.go +index 8c2e70fa22e..8c940aefb81 100644 +--- a/src/encoding/xml/read_test.go ++++ b/src/encoding/xml/read_test.go +@@ -5,8 +5,11 @@ + package xml + + import ( ++ "bytes" ++ "errors" + "io" + "reflect" ++ "runtime" + "strings" + "testing" + "time" +@@ -1079,3 +1082,32 @@ func TestUnmarshalWhitespaceAttrs(t *testing.T) { + t.Fatalf("whitespace attrs: Unmarshal:\nhave: %#+v\nwant: %#+v", v, want) + } + } ++ ++func TestCVE202230633(t *testing.T) { ++ if runtime.GOARCH == "wasm" { ++ t.Skip("causes memory exhaustion on js/wasm") ++ } ++ defer func() { ++ p := recover() ++ if p != nil { ++ t.Fatal("Unmarshal panicked") ++ } ++ }() ++ var example struct { ++ Things []string ++ } ++ Unmarshal(bytes.Repeat([]byte(""), 17_000_000), &example) ++} ++ ++func TestCVE202228131(t *testing.T) { ++ type nested struct { ++ Parent *nested `xml:",any"` ++ } ++ var n nested ++ err := Unmarshal(bytes.Repeat([]byte(""), maxUnmarshalDepth+1), &n) ++ if err == nil { ++ t.Fatal("Unmarshal did not fail") ++ } else if !errors.Is(err, errExeceededMaxUnmarshalDepth) { ++ t.Fatalf("Unmarshal unexpected error: got %q, want %q", err, errExeceededMaxUnmarshalDepth) ++ } ++} +-- +2.30.2 + diff --git a/0009-release-branch.go1.17-encoding-gob-add-a-depth-limit.patch b/0009-release-branch.go1.17-encoding-gob-add-a-depth-limit.patch new file mode 100644 index 0000000000000000000000000000000000000000..13f56a5ce339c494603c9e8c1a7c47bcf8a318f4 --- /dev/null +++ b/0009-release-branch.go1.17-encoding-gob-add-a-depth-limit.patch @@ -0,0 +1,138 @@ +From 8747af9a1098e8fa497441be4c4a79a23de31a98 Mon Sep 17 00:00:00 2001 +From: Roland Shoemaker +Date: Tue, 7 Jun 2022 13:00:43 -0700 +Subject: [PATCH 05/11] [release-branch.go1.17] encoding/gob: add a depth limit + for ignored fields + +Enforce a nesting limit of 10,000 for ignored fields during decoding +of messages. This prevents the possibility of triggering stack +exhaustion. + +Fixes #53709 +Updates #53615 +Fixes CVE-2022-30635 + +Change-Id: I05103d06dd5ca3945fcba3c1f5d3b5a645e8fb0f +Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1484771 +Reviewed-by: Damien Neil +Reviewed-by: Tatiana Bradley +(cherry picked from commit 55e8f938d22bfec29cc9dc9671044c5a41d1ea9c) +Reviewed-on: https://go-review.googlesource.com/c/go/+/417074 +Run-TryBot: Heschi Kreinick +TryBot-Result: Gopher Robot +Reviewed-by: Heschi Kreinick + +Conflict: NA +Reference: https://go-review.googlesource.com/c/go/+/417074 +--- + src/encoding/gob/decode.go | 19 ++++++++++++------- + src/encoding/gob/gobencdec_test.go | 24 ++++++++++++++++++++++++ + 2 files changed, 36 insertions(+), 7 deletions(-) + +diff --git a/src/encoding/gob/decode.go b/src/encoding/gob/decode.go +index d2f6c749b1b..0e0ec75cccc 100644 +--- a/src/encoding/gob/decode.go ++++ b/src/encoding/gob/decode.go +@@ -871,8 +871,13 @@ func (dec *Decoder) decOpFor(wireId typeId, rt reflect.Type, name string, inProg + return &op + } + ++var maxIgnoreNestingDepth = 10000 ++ + // decIgnoreOpFor returns the decoding op for a field that has no destination. +-func (dec *Decoder) decIgnoreOpFor(wireId typeId, inProgress map[typeId]*decOp) *decOp { ++func (dec *Decoder) decIgnoreOpFor(wireId typeId, inProgress map[typeId]*decOp, depth int) *decOp { ++ if depth > maxIgnoreNestingDepth { ++ error_(errors.New("invalid nesting depth")) ++ } + // If this type is already in progress, it's a recursive type (e.g. map[string]*T). + // Return the pointer to the op we're already building. + if opPtr := inProgress[wireId]; opPtr != nil { +@@ -896,7 +901,7 @@ func (dec *Decoder) decIgnoreOpFor(wireId typeId, inProgress map[typeId]*decOp) + errorf("bad data: undefined type %s", wireId.string()) + case wire.ArrayT != nil: + elemId := wire.ArrayT.Elem +- elemOp := dec.decIgnoreOpFor(elemId, inProgress) ++ elemOp := dec.decIgnoreOpFor(elemId, inProgress, depth+1) + op = func(i *decInstr, state *decoderState, value reflect.Value) { + state.dec.ignoreArray(state, *elemOp, wire.ArrayT.Len) + } +@@ -904,15 +909,15 @@ func (dec *Decoder) decIgnoreOpFor(wireId typeId, inProgress map[typeId]*decOp) + case wire.MapT != nil: + keyId := dec.wireType[wireId].MapT.Key + elemId := dec.wireType[wireId].MapT.Elem +- keyOp := dec.decIgnoreOpFor(keyId, inProgress) +- elemOp := dec.decIgnoreOpFor(elemId, inProgress) ++ keyOp := dec.decIgnoreOpFor(keyId, inProgress, depth+1) ++ elemOp := dec.decIgnoreOpFor(elemId, inProgress, depth+1) + op = func(i *decInstr, state *decoderState, value reflect.Value) { + state.dec.ignoreMap(state, *keyOp, *elemOp) + } + + case wire.SliceT != nil: + elemId := wire.SliceT.Elem +- elemOp := dec.decIgnoreOpFor(elemId, inProgress) ++ elemOp := dec.decIgnoreOpFor(elemId, inProgress, depth+1) + op = func(i *decInstr, state *decoderState, value reflect.Value) { + state.dec.ignoreSlice(state, *elemOp) + } +@@ -1073,7 +1078,7 @@ func (dec *Decoder) compileSingle(remoteId typeId, ut *userTypeInfo) (engine *de + func (dec *Decoder) compileIgnoreSingle(remoteId typeId) *decEngine { + engine := new(decEngine) + engine.instr = make([]decInstr, 1) // one item +- op := dec.decIgnoreOpFor(remoteId, make(map[typeId]*decOp)) ++ op := dec.decIgnoreOpFor(remoteId, make(map[typeId]*decOp), 0) + ovfl := overflow(dec.typeString(remoteId)) + engine.instr[0] = decInstr{*op, 0, nil, ovfl} + engine.numInstr = 1 +@@ -1118,7 +1123,7 @@ func (dec *Decoder) compileDec(remoteId typeId, ut *userTypeInfo) (engine *decEn + localField, present := srt.FieldByName(wireField.Name) + // TODO(r): anonymous names + if !present || !isExported(wireField.Name) { +- op := dec.decIgnoreOpFor(wireField.Id, make(map[typeId]*decOp)) ++ op := dec.decIgnoreOpFor(wireField.Id, make(map[typeId]*decOp), 0) + engine.instr[fieldnum] = decInstr{*op, fieldnum, nil, ovfl} + continue + } +diff --git a/src/encoding/gob/gobencdec_test.go b/src/encoding/gob/gobencdec_test.go +index 6d2c8db42d0..1b52ecc6c84 100644 +--- a/src/encoding/gob/gobencdec_test.go ++++ b/src/encoding/gob/gobencdec_test.go +@@ -12,6 +12,7 @@ import ( + "fmt" + "io" + "net" ++ "reflect" + "strings" + "testing" + "time" +@@ -796,3 +797,26 @@ func TestNetIP(t *testing.T) { + t.Errorf("decoded to %v, want 1.2.3.4", ip.String()) + } + } ++ ++func TestIngoreDepthLimit(t *testing.T) { ++ // We don't test the actual depth limit because it requires building an ++ // extremely large message, which takes quite a while. ++ oldNestingDepth := maxIgnoreNestingDepth ++ maxIgnoreNestingDepth = 100 ++ defer func() { maxIgnoreNestingDepth = oldNestingDepth }() ++ b := new(bytes.Buffer) ++ enc := NewEncoder(b) ++ typ := reflect.TypeOf(int(0)) ++ nested := reflect.ArrayOf(1, typ) ++ for i := 0; i < 100; i++ { ++ nested = reflect.ArrayOf(1, nested) ++ } ++ badStruct := reflect.New(reflect.StructOf([]reflect.StructField{{Name: "F", Type: nested}})) ++ enc.Encode(badStruct.Interface()) ++ dec := NewDecoder(b) ++ var output struct{ Hello int } ++ expectedErr := "invalid nesting depth" ++ if err := dec.Decode(&output); err == nil || err.Error() != expectedErr { ++ t.Errorf("Decode didn't fail with depth limit of 100: want %q, got %q", expectedErr, err) ++ } ++} +-- +2.30.2 + diff --git a/0010-release-branch.go1.17-io-fs-fix-stack-exhaustion-in-.patch b/0010-release-branch.go1.17-io-fs-fix-stack-exhaustion-in-.patch new file mode 100644 index 0000000000000000000000000000000000000000..c1943787ed4deeb3a6687cd4fd560c68b9dbac4c --- /dev/null +++ b/0010-release-branch.go1.17-io-fs-fix-stack-exhaustion-in-.patch @@ -0,0 +1,96 @@ +From a8d44d0477f2182563e279da115cbc164d639f33 Mon Sep 17 00:00:00 2001 +From: Julie Qiu +Date: Thu, 23 Jun 2022 23:17:53 +0000 +Subject: [PATCH 06/11] [release-branch.go1.17] io/fs: fix stack exhaustion in + Glob + +A limit is added to the number of path separators allowed by an input to +Glob, to prevent stack exhaustion issues. + +Thanks to Juho Nurminen of Mattermost who reported a similar issue in +path/filepath. + +Fixes #53719 +Updates #53415 +Fixes CVE-2022-30630 + +Change-Id: I5a9d02591fed90cd3d52627f5945f1301e53465d +Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1497588 +Reviewed-by: Roland Shoemaker +(cherry picked from commit fdccc5d7bd0f276d0a8de3a818ca844f0bed5d97) +Reviewed-on: https://go-review.googlesource.com/c/go/+/417072 +Reviewed-by: Heschi Kreinick +TryBot-Result: Gopher Robot +Run-TryBot: Michael Knyszek + +Conflict: NA +Reference: https://go-review.googlesource.com/c/go/+/417072 +--- + src/io/fs/glob.go | 14 ++++++++++++-- + src/io/fs/glob_test.go | 10 ++++++++++ + 2 files changed, 22 insertions(+), 2 deletions(-) + +diff --git a/src/io/fs/glob.go b/src/io/fs/glob.go +index 45d9cb61b96..0e529cd05d1 100644 +--- a/src/io/fs/glob.go ++++ b/src/io/fs/glob.go +@@ -31,6 +31,16 @@ type GlobFS interface { + // Otherwise, Glob uses ReadDir to traverse the directory tree + // and look for matches for the pattern. + func Glob(fsys FS, pattern string) (matches []string, err error) { ++ return globWithLimit(fsys, pattern, 0) ++} ++ ++func globWithLimit(fsys FS, pattern string, depth int) (matches []string, err error) { ++ // This limit is added to prevent stack exhaustion issues. See ++ // CVE-2022-30630. ++ const pathSeparatorsLimit = 10000 ++ if depth > pathSeparatorsLimit { ++ return nil, path.ErrBadPattern ++ } + if fsys, ok := fsys.(GlobFS); ok { + return fsys.Glob(pattern) + } +@@ -59,9 +69,9 @@ func Glob(fsys FS, pattern string) (matches []string, err error) { + } + + var m []string +- m, err = Glob(fsys, dir) ++ m, err = globWithLimit(fsys, dir, depth+1) + if err != nil { +- return ++ return nil, err + } + for _, d := range m { + matches, err = glob(fsys, d, file, matches) +diff --git a/src/io/fs/glob_test.go b/src/io/fs/glob_test.go +index f19bebed77f..d052eab3713 100644 +--- a/src/io/fs/glob_test.go ++++ b/src/io/fs/glob_test.go +@@ -8,6 +8,7 @@ import ( + . "io/fs" + "os" + "path" ++ "strings" + "testing" + ) + +@@ -55,6 +56,15 @@ func TestGlobError(t *testing.T) { + } + } + ++func TestCVE202230630(t *testing.T) { ++ // Prior to CVE-2022-30630, a stack exhaustion would occur given a large ++ // number of separators. There is now a limit of 10,000. ++ _, err := Glob(os.DirFS("."), "/*"+strings.Repeat("/", 10001)) ++ if err != path.ErrBadPattern { ++ t.Fatalf("Glob returned err=%v, want %v", err, path.ErrBadPattern) ++ } ++} ++ + // contains reports whether vector contains the string s. + func contains(vector []string, s string) bool { + for _, elem := range vector { +-- +2.30.2 + diff --git a/0011-release-branch.go1.17-path-filepath-fix-stack-exhaus.patch b/0011-release-branch.go1.17-path-filepath-fix-stack-exhaus.patch new file mode 100644 index 0000000000000000000000000000000000000000..661634ac3dabe484b61c160c12218f3fb5a04700 --- /dev/null +++ b/0011-release-branch.go1.17-path-filepath-fix-stack-exhaus.patch @@ -0,0 +1,85 @@ +From 7b98bf3a8711126c532033ca89647f3b743b58ec Mon Sep 17 00:00:00 2001 +From: Julie Qiu +Date: Thu, 23 Jun 2022 23:18:56 +0000 +Subject: [PATCH 07/11] [release-branch.go1.17] path/filepath: fix stack + exhaustion in Glob + +A limit is added to the number of path separators allowed by an input to +Glob, to prevent stack exhaustion issues. + +Thanks to Juho Nurminen of Mattermost who reported the issue. + +Fixes #53713 +Updates #53416 +Fixes CVE-2022-30632 + +Change-Id: I1b9fd4faa85411a05dbc91dceae1c0c8eb021f07 +Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1498176 +Reviewed-by: Roland Shoemaker +(cherry picked from commit d182a6d1217fd0d04c9babfa9a7ccd3515435c39) +Reviewed-on: https://go-review.googlesource.com/c/go/+/417073 +Reviewed-by: Heschi Kreinick +TryBot-Result: Gopher Robot +Run-TryBot: Michael Knyszek + +Conflict: NA +Reference: https://go-review.googlesource.com/c/go/+/417073 +--- + src/path/filepath/match.go | 12 +++++++++++- + src/path/filepath/match_test.go | 10 ++++++++++ + 2 files changed, 21 insertions(+), 1 deletion(-) + +diff --git a/src/path/filepath/match.go b/src/path/filepath/match.go +index c77a26952a6..55ed1d75ae1 100644 +--- a/src/path/filepath/match.go ++++ b/src/path/filepath/match.go +@@ -241,6 +241,16 @@ func getEsc(chunk string) (r rune, nchunk string, err error) { + // The only possible returned error is ErrBadPattern, when pattern + // is malformed. + func Glob(pattern string) (matches []string, err error) { ++ return globWithLimit(pattern, 0) ++} ++ ++func globWithLimit(pattern string, depth int) (matches []string, err error) { ++ // This limit is used prevent stack exhaustion issues. See CVE-2022-30632. ++ const pathSeparatorsLimit = 10000 ++ if depth == pathSeparatorsLimit { ++ return nil, ErrBadPattern ++ } ++ + // Check pattern is well-formed. + if _, err := Match(pattern, ""); err != nil { + return nil, err +@@ -270,7 +280,7 @@ func Glob(pattern string) (matches []string, err error) { + } + + var m []string +- m, err = Glob(dir) ++ m, err = globWithLimit(dir, depth+1) + if err != nil { + return + } +diff --git a/src/path/filepath/match_test.go b/src/path/filepath/match_test.go +index 375c41a7e9d..d6282596fed 100644 +--- a/src/path/filepath/match_test.go ++++ b/src/path/filepath/match_test.go +@@ -155,6 +155,16 @@ func TestGlob(t *testing.T) { + } + } + ++func TestCVE202230632(t *testing.T) { ++ // Prior to CVE-2022-30632, this would cause a stack exhaustion given a ++ // large number of separators (more than 4,000,000). There is now a limit ++ // of 10,000. ++ _, err := Glob("/*" + strings.Repeat("/", 10001)) ++ if err != ErrBadPattern { ++ t.Fatalf("Glob returned err=%v, want ErrBadPattern", err) ++ } ++} ++ + func TestGlobError(t *testing.T) { + bad := []string{`[]`, `nonexist/[]`} + for _, pattern := range bad { +-- +2.30.2 + diff --git a/0012-release-branch.go1.17-encoding-xml-use-iterative-Ski.patch b/0012-release-branch.go1.17-encoding-xml-use-iterative-Ski.patch new file mode 100644 index 0000000000000000000000000000000000000000..9be1eea8260baee823f1d033a0493f36a0efb8e1 --- /dev/null +++ b/0012-release-branch.go1.17-encoding-xml-use-iterative-Ski.patch @@ -0,0 +1,69 @@ +From cedbe8f7a1f0d174636e70de68d85499d8025000 Mon Sep 17 00:00:00 2001 +From: Roland Shoemaker +Date: Mon, 28 Mar 2022 18:41:26 -0700 +Subject: [PATCH 08/11] [release-branch.go1.17] encoding/xml: use iterative + Skip, rather than recursive + +Prevents exhausting the stack limit in _incredibly_ deeply nested +structures. + +Fixes #53711 +Updates #53614 +Fixes CVE-2022-28131 + +Change-Id: I47db4595ce10cecc29fbd06afce7b299868599e6 +Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1419912 +Reviewed-by: Julie Qiu +Reviewed-by: Damien Neil +(cherry picked from commit 9278cb78443d2b4deb24cbb5b61c9ba5ac688d49) +Reviewed-on: https://go-review.googlesource.com/c/go/+/417068 +TryBot-Result: Gopher Robot +Reviewed-by: Heschi Kreinick +Run-TryBot: Michael Knyszek + +Conflict: NA +Reference: https://go-review.googlesource.com/c/go/+/417068 +--- + src/encoding/xml/read.go | 15 ++++++++------- + 1 file changed, 8 insertions(+), 7 deletions(-) + +diff --git a/src/encoding/xml/read.go b/src/encoding/xml/read.go +index e0ed8b527ce..c77579880cb 100644 +--- a/src/encoding/xml/read.go ++++ b/src/encoding/xml/read.go +@@ -743,12 +743,12 @@ Loop: + } + + // Skip reads tokens until it has consumed the end element +-// matching the most recent start element already consumed. +-// It recurs if it encounters a start element, so it can be used to +-// skip nested structures. ++// matching the most recent start element already consumed, ++// skipping nested structures. + // It returns nil if it finds an end element matching the start + // element; otherwise it returns an error describing the problem. + func (d *Decoder) Skip() error { ++ var depth int64 + for { + tok, err := d.Token() + if err != nil { +@@ -756,11 +756,12 @@ func (d *Decoder) Skip() error { + } + switch tok.(type) { + case StartElement: +- if err := d.Skip(); err != nil { +- return err +- } ++ depth++ + case EndElement: +- return nil ++ if depth == 0 { ++ return nil ++ } ++ depth-- + } + } + } +-- +2.30.2 + diff --git a/0013-release-branch.go1.17-compress-gzip-fix-stack-exhaus.patch b/0013-release-branch.go1.17-compress-gzip-fix-stack-exhaus.patch new file mode 100644 index 0000000000000000000000000000000000000000..7a54a71ea1789a38b6e07405b4c2d47766b75f08 --- /dev/null +++ b/0013-release-branch.go1.17-compress-gzip-fix-stack-exhaus.patch @@ -0,0 +1,133 @@ +From 8a445abc7f7e2ed41112f176a169b97859c8d425 Mon Sep 17 00:00:00 2001 +From: Tatiana Bradley +Date: Fri, 6 May 2022 11:25:06 -0400 +Subject: [PATCH 09/11] [release-branch.go1.17] compress/gzip: fix stack + exhaustion bug in Reader.Read + +Replace recursion with iteration in Reader.Read to avoid stack +exhaustion when there are a large number of files. + +Fixes CVE-2022-30631 +Fixes #53717 +Updates #53168 + +Change-Id: I47d8afe3f2d40b0213ab61431df9b221794dbfe0 +Reviewed-on: https://team-review.git.corp.google.com/c/golang/go-private/+/1455673 +Reviewed-by: Roland Shoemaker +Reviewed-by: Julie Qiu +(cherry picked from commit cf498969c8a0bae9d7a24b98fc1f66c824a4775d) +Reviewed-on: https://go-review.googlesource.com/c/go/+/417071 +Reviewed-by: Heschi Kreinick +Run-TryBot: Michael Knyszek +TryBot-Result: Gopher Robot + +Conflict: NA +Reference: https://go-review.googlesource.com/c/go/+/417071 +--- + src/compress/gzip/gunzip.go | 60 +++++++++++++++----------------- + src/compress/gzip/gunzip_test.go | 16 +++++++++ + 2 files changed, 45 insertions(+), 31 deletions(-) + +diff --git a/src/compress/gzip/gunzip.go b/src/compress/gzip/gunzip.go +index 924bce10b7c..237b2b928bf 100644 +--- a/src/compress/gzip/gunzip.go ++++ b/src/compress/gzip/gunzip.go +@@ -248,42 +248,40 @@ func (z *Reader) Read(p []byte) (n int, err error) { + return 0, z.err + } + +- n, z.err = z.decompressor.Read(p) +- z.digest = crc32.Update(z.digest, crc32.IEEETable, p[:n]) +- z.size += uint32(n) +- if z.err != io.EOF { +- // In the normal case we return here. +- return n, z.err +- } ++ for n == 0 { ++ n, z.err = z.decompressor.Read(p) ++ z.digest = crc32.Update(z.digest, crc32.IEEETable, p[:n]) ++ z.size += uint32(n) ++ if z.err != io.EOF { ++ // In the normal case we return here. ++ return n, z.err ++ } + +- // Finished file; check checksum and size. +- if _, err := io.ReadFull(z.r, z.buf[:8]); err != nil { +- z.err = noEOF(err) +- return n, z.err +- } +- digest := le.Uint32(z.buf[:4]) +- size := le.Uint32(z.buf[4:8]) +- if digest != z.digest || size != z.size { +- z.err = ErrChecksum +- return n, z.err +- } +- z.digest, z.size = 0, 0 ++ // Finished file; check checksum and size. ++ if _, err := io.ReadFull(z.r, z.buf[:8]); err != nil { ++ z.err = noEOF(err) ++ return n, z.err ++ } ++ digest := le.Uint32(z.buf[:4]) ++ size := le.Uint32(z.buf[4:8]) ++ if digest != z.digest || size != z.size { ++ z.err = ErrChecksum ++ return n, z.err ++ } ++ z.digest, z.size = 0, 0 + +- // File is ok; check if there is another. +- if !z.multistream { +- return n, io.EOF +- } +- z.err = nil // Remove io.EOF ++ // File is ok; check if there is another. ++ if !z.multistream { ++ return n, io.EOF ++ } ++ z.err = nil // Remove io.EOF + +- if _, z.err = z.readHeader(); z.err != nil { +- return n, z.err ++ if _, z.err = z.readHeader(); z.err != nil { ++ return n, z.err ++ } + } + +- // Read from next file, if necessary. +- if n > 0 { +- return n, nil +- } +- return z.Read(p) ++ return n, nil + } + + // Close closes the Reader. It does not close the underlying io.Reader. +diff --git a/src/compress/gzip/gunzip_test.go b/src/compress/gzip/gunzip_test.go +index 17c23e8a9be..6fe8ddcf558 100644 +--- a/src/compress/gzip/gunzip_test.go ++++ b/src/compress/gzip/gunzip_test.go +@@ -515,3 +515,19 @@ func TestTruncatedStreams(t *testing.T) { + } + } + } ++ ++func TestCVE202230631(t *testing.T) { ++ var empty = []byte{0x1f, 0x8b, 0x08, 0x00, 0xa7, 0x8f, 0x43, 0x62, 0x00, ++ 0x03, 0x03, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} ++ r := bytes.NewReader(bytes.Repeat(empty, 4e6)) ++ z, err := NewReader(r) ++ if err != nil { ++ t.Fatalf("NewReader: got %v, want nil", err) ++ } ++ // Prior to CVE-2022-30631 fix, this would cause an unrecoverable panic due ++ // to stack exhaustion. ++ _, err = z.Read(make([]byte, 10)) ++ if err != io.EOF { ++ t.Errorf("Reader.Read: got %v, want %v", err, io.EOF) ++ } ++} +-- +2.30.2 + diff --git a/0014-release-branch.go1.17-crypto-tls-randomly-generate-t.patch b/0014-release-branch.go1.17-crypto-tls-randomly-generate-t.patch new file mode 100644 index 0000000000000000000000000000000000000000..f8f418a62b7f0a81fcd8bd8ae61ed498bf433228 --- /dev/null +++ b/0014-release-branch.go1.17-crypto-tls-randomly-generate-t.patch @@ -0,0 +1,69 @@ +From b2815a72bef3f829c5ac7735feddb034f5501cc0 Mon Sep 17 00:00:00 2001 +From: Tatiana Bradley +Date: Thu, 12 May 2022 14:58:29 -0400 +Subject: [PATCH 10/11] [release-branch.go1.17] crypto/tls: randomly generate + ticket_age_add + +As required by RFC 8446, section 4.6.1, ticket_age_add now holds a +random 32-bit value. Before this change, this value was always set +to 0. + +This change also documents the reasoning for always setting +ticket_nonce to 0. The value ticket_nonce must be unique per +connection, but we only ever send one ticket per connection. + +Updates #52814 +Fixes #52832 +Fixes CVE-2022-30629 + +Change-Id: I6c2fc6ca0376b7b968abd59d6d3d3854c1ab68bb +Reviewed-on: https://go-review.googlesource.com/c/go/+/405994 +Reviewed-by: Tatiana Bradley +Reviewed-by: Roland Shoemaker +Run-TryBot: Tatiana Bradley +TryBot-Result: Gopher Robot +(cherry picked from commit fe4de36198794c447fbd9d7cc2d7199a506c76a5) +Reviewed-on: https://go-review.googlesource.com/c/go/+/408574 +Run-TryBot: Roland Shoemaker + +Conflict: NA +Reference: https://go-review.googlesource.com/c/go/+/408574 +--- + src/crypto/tls/handshake_server_tls13.go | 14 ++++++++++++++ + 1 file changed, 14 insertions(+) + +diff --git a/src/crypto/tls/handshake_server_tls13.go b/src/crypto/tls/handshake_server_tls13.go +index 08251b84def..6aa52698a3a 100644 +--- a/src/crypto/tls/handshake_server_tls13.go ++++ b/src/crypto/tls/handshake_server_tls13.go +@@ -10,6 +10,7 @@ import ( + "crypto" + "crypto/hmac" + "crypto/rsa" ++ "encoding/binary" + "errors" + "hash" + "io" +@@ -741,6 +742,19 @@ func (hs *serverHandshakeStateTLS13) sendSessionTickets() error { + } + m.lifetime = uint32(maxSessionTicketLifetime / time.Second) + ++ // ticket_age_add is a random 32-bit value. See RFC 8446, section 4.6.1 ++ // The value is not stored anywhere; we never need to check the ticket age ++ // because 0-RTT is not supported. ++ ageAdd := make([]byte, 4) ++ _, err = hs.c.config.rand().Read(ageAdd) ++ if err != nil { ++ return err ++ } ++ m.ageAdd = binary.LittleEndian.Uint32(ageAdd) ++ ++ // ticket_nonce, which must be unique per connection, is always left at ++ // zero because we only ever send one ticket per connection. ++ + if _, err := c.writeRecord(recordTypeHandshake, m.marshal()); err != nil { + return err + } +-- +2.30.2 + diff --git a/0015-release-branch.go1.17-crypto-rand-properly-handle-la.patch b/0015-release-branch.go1.17-crypto-rand-properly-handle-la.patch new file mode 100644 index 0000000000000000000000000000000000000000..092814022de625d9ed3205ff3821ec33ae0f0350 --- /dev/null +++ b/0015-release-branch.go1.17-crypto-rand-properly-handle-la.patch @@ -0,0 +1,246 @@ +From 07a30769186210c1b1e25943824743355c4e50f5 Mon Sep 17 00:00:00 2001 +From: Roland Shoemaker +Date: Mon, 25 Apr 2022 19:02:35 -0700 +Subject: [PATCH 11/11] [release-branch.go1.17] crypto/rand: properly handle + large Read on windows + +Use the batched reader to chunk large Read calls on windows to a max of +1 << 31 - 1 bytes. This prevents an infinite loop when trying to read +more than 1 << 32 -1 bytes, due to how RtlGenRandom works. + +This change moves the batched function from rand_unix.go to rand.go, +since it is now needed for both windows and unix implementations. + +Updates #52561 +Fixes #52932 +Fixes CVE-2022-30634 + +Change-Id: Id98fc4b1427e5cb2132762a445b2aed646a37473 +Reviewed-on: https://go-review.googlesource.com/c/go/+/402257 +Run-TryBot: Roland Shoemaker +Reviewed-by: Filippo Valsorda +Reviewed-by: Filippo Valsorda +TryBot-Result: Gopher Robot +(cherry picked from commit bb1f4416180511231de6d17a1f2f55c82aafc863) +Reviewed-on: https://go-review.googlesource.com/c/go/+/406635 +Reviewed-by: Damien Neil + +Conflict: NA +Reference: https://go-review.googlesource.com/c/go/+/406635 +--- + src/crypto/rand/rand.go | 18 ++++++++++++++++++ + src/crypto/rand/rand_batched.go | 22 ++++++---------------- + src/crypto/rand/rand_batched_test.go | 21 +++++++++++---------- + src/crypto/rand/rand_getentropy.go | 6 +++--- + src/crypto/rand/rand_unix.go | 4 ++-- + src/crypto/rand/rand_windows.go | 18 ++++++------------ + 6 files changed, 46 insertions(+), 43 deletions(-) + +diff --git a/src/crypto/rand/rand.go b/src/crypto/rand/rand.go +index fddd1147e6e..f2c276008d7 100644 +--- a/src/crypto/rand/rand.go ++++ b/src/crypto/rand/rand.go +@@ -23,3 +23,21 @@ var Reader io.Reader + func Read(b []byte) (n int, err error) { + return io.ReadFull(Reader, b) + } ++ ++// batched returns a function that calls f to populate a []byte by chunking it ++// into subslices of, at most, readMax bytes. ++func batched(f func([]byte) error, readMax int) func([]byte) error { ++ return func(out []byte) error { ++ for len(out) > 0 { ++ read := len(out) ++ if read > readMax { ++ read = readMax ++ } ++ if err := f(out[:read]); err != nil { ++ return err ++ } ++ out = out[read:] ++ } ++ return nil ++ } ++} +diff --git a/src/crypto/rand/rand_batched.go b/src/crypto/rand/rand_batched.go +index d7c5bf3562d..8df715fdd14 100644 +--- a/src/crypto/rand/rand_batched.go ++++ b/src/crypto/rand/rand_batched.go +@@ -8,6 +8,7 @@ + package rand + + import ( ++ "errors" + "internal/syscall/unix" + ) + +@@ -16,20 +17,6 @@ func init() { + altGetRandom = batched(getRandomBatch, maxGetRandomRead) + } + +-// batched returns a function that calls f to populate a []byte by chunking it +-// into subslices of, at most, readMax bytes. +-func batched(f func([]byte) bool, readMax int) func([]byte) bool { +- return func(buf []byte) bool { +- for len(buf) > readMax { +- if !f(buf[:readMax]) { +- return false +- } +- buf = buf[readMax:] +- } +- return len(buf) == 0 || f(buf) +- } +-} +- + // If the kernel is too old to support the getrandom syscall(), + // unix.GetRandom will immediately return ENOSYS and we will then fall back to + // reading from /dev/urandom in rand_unix.go. unix.GetRandom caches the ENOSYS +@@ -37,7 +24,10 @@ func batched(f func([]byte) bool, readMax int) func([]byte) bool { + // If the kernel supports the getrandom() syscall, unix.GetRandom will block + // until the kernel has sufficient randomness (as we don't use GRND_NONBLOCK). + // In this case, unix.GetRandom will not return an error. +-func getRandomBatch(p []byte) (ok bool) { ++func getRandomBatch(p []byte) error { + n, err := unix.GetRandom(p, 0) +- return n == len(p) && err == nil ++ if n != len(p) { ++ return errors.New("short read") ++ } ++ return err + } +diff --git a/src/crypto/rand/rand_batched_test.go b/src/crypto/rand/rand_batched_test.go +index 2d20922c825..b56345e50f1 100644 +--- a/src/crypto/rand/rand_batched_test.go ++++ b/src/crypto/rand/rand_batched_test.go +@@ -9,20 +9,21 @@ package rand + + import ( + "bytes" ++ "errors" + "testing" + ) + + func TestBatched(t *testing.T) { +- fillBatched := batched(func(p []byte) bool { ++ fillBatched := batched(func(p []byte) error { + for i := range p { + p[i] = byte(i) + } +- return true ++ return nil + }, 5) + + p := make([]byte, 13) +- if !fillBatched(p) { +- t.Fatal("batched function returned false") ++ if err := fillBatched(p); err != nil { ++ t.Fatalf("batched function returned error: %s", err) + } + expected := []byte{0, 1, 2, 3, 4, 0, 1, 2, 3, 4, 0, 1, 2} + if !bytes.Equal(expected, p) { +@@ -31,15 +32,15 @@ func TestBatched(t *testing.T) { + } + + func TestBatchedError(t *testing.T) { +- b := batched(func(p []byte) bool { return false }, 5) +- if b(make([]byte, 13)) { +- t.Fatal("batched function should have returned false") ++ b := batched(func(p []byte) error { return errors.New("") }, 5) ++ if b(make([]byte, 13)) == nil { ++ t.Fatal("batched function should have returned an error") + } + } + + func TestBatchedEmpty(t *testing.T) { +- b := batched(func(p []byte) bool { return false }, 5) +- if !b(make([]byte, 0)) { +- t.Fatal("empty slice should always return true") ++ b := batched(func(p []byte) error { return errors.New("") }, 5) ++ if err := b(make([]byte, 0)); err != nil { ++ t.Fatalf("empty slice should always return nil: %s", err) + } + } +diff --git a/src/crypto/rand/rand_getentropy.go b/src/crypto/rand/rand_getentropy.go +index dd725372ad9..b1c19f3d0da 100644 +--- a/src/crypto/rand/rand_getentropy.go ++++ b/src/crypto/rand/rand_getentropy.go +@@ -15,7 +15,7 @@ func init() { + altGetRandom = getEntropy + } + +-func getEntropy(p []byte) (ok bool) { ++func getEntropy(p []byte) error { + // getentropy(2) returns a maximum of 256 bytes per call + for i := 0; i < len(p); i += 256 { + end := i + 256 +@@ -24,8 +24,8 @@ func getEntropy(p []byte) (ok bool) { + } + err := unix.GetEntropy(p[i:end]) + if err != nil { +- return false ++ return err + } + } +- return true ++ return nil + } +diff --git a/src/crypto/rand/rand_unix.go b/src/crypto/rand/rand_unix.go +index 81277eb6a5d..3d11159a340 100644 +--- a/src/crypto/rand/rand_unix.go ++++ b/src/crypto/rand/rand_unix.go +@@ -46,7 +46,7 @@ type devReader struct { + + // altGetRandom if non-nil specifies an OS-specific function to get + // urandom-style randomness. +-var altGetRandom func([]byte) (ok bool) ++var altGetRandom func([]byte) (err error) + + func warnBlocked() { + println("crypto/rand: blocked for 60 seconds waiting to read random data from the kernel") +@@ -59,7 +59,7 @@ func (r *devReader) Read(b []byte) (n int, err error) { + t := time.AfterFunc(60*time.Second, warnBlocked) + defer t.Stop() + } +- if altGetRandom != nil && r.name == urandomDevice && altGetRandom(b) { ++ if altGetRandom != nil && r.name == urandomDevice && altGetRandom(b) == nil { + return len(b), nil + } + r.mu.Lock() +diff --git a/src/crypto/rand/rand_windows.go b/src/crypto/rand/rand_windows.go +index 7379f1489ad..6c0655c72b6 100644 +--- a/src/crypto/rand/rand_windows.go ++++ b/src/crypto/rand/rand_windows.go +@@ -9,7 +9,6 @@ package rand + + import ( + "internal/syscall/windows" +- "os" + ) + + func init() { Reader = &rngReader{} } +@@ -17,16 +16,11 @@ func init() { Reader = &rngReader{} } + type rngReader struct{} + + func (r *rngReader) Read(b []byte) (n int, err error) { +- // RtlGenRandom only accepts 2**32-1 bytes at a time, so truncate. +- inputLen := uint32(len(b)) +- +- if inputLen == 0 { +- return 0, nil +- } +- +- err = windows.RtlGenRandom(b) +- if err != nil { +- return 0, os.NewSyscallError("RtlGenRandom", err) ++ // RtlGenRandom only returns 1<<32-1 bytes at a time. We only read at ++ // most 1<<31-1 bytes at a time so that this works the same on 32-bit ++ // and 64-bit systems. ++ if err := batched(windows.RtlGenRandom, 1<<31-1)(b); err != nil { ++ return 0, err + } +- return int(inputLen), nil ++ return len(b), nil + } +-- +2.30.2 + diff --git a/0016-release-branch.go1.17-math-big-check-buffer-lengths-.patch b/0016-release-branch.go1.17-math-big-check-buffer-lengths-.patch new file mode 100644 index 0000000000000000000000000000000000000000..78f8090c522ff73f635f567a3ce02cd46d419180 --- /dev/null +++ b/0016-release-branch.go1.17-math-big-check-buffer-lengths-.patch @@ -0,0 +1,125 @@ +From dc903a8196a831d23e9b6504239e09a9e6bcd98a Mon Sep 17 00:00:00 2001 +From: Roland Shoemaker +Date: Fri, 15 Jul 2022 10:43:44 -0700 +Subject: [PATCH] [release-branch.go1.17] math/big: check buffer lengths in + GobDecode + +In Float.GobDecode and Rat.GobDecode, check buffer sizes before +indexing slices. + +Updates #53871 +Fixes #54094 + +Change-Id: I1b652c32c2bc7a0e8aa7620f7be9b2740c568b0a +Reviewed-on: https://go-review.googlesource.com/c/go/+/417774 +TryBot-Result: Gopher Robot +Reviewed-by: Tatiana Bradley +Run-TryBot: Roland Shoemaker +(cherry picked from commit 055113ef364337607e3e72ed7d48df67fde6fc66) +Reviewed-on: https://go-review.googlesource.com/c/go/+/419814 +Reviewed-by: Julie Qiu +--- + src/math/big/floatmarsh.go | 7 +++++++ + src/math/big/floatmarsh_test.go | 12 ++++++++++++ + src/math/big/ratmarsh.go | 6 ++++++ + src/math/big/ratmarsh_test.go | 12 ++++++++++++ + 4 files changed, 37 insertions(+) + +diff --git a/src/math/big/floatmarsh.go b/src/math/big/floatmarsh.go +index d1c1dab069..990e085abe 100644 +--- a/src/math/big/floatmarsh.go ++++ b/src/math/big/floatmarsh.go +@@ -8,6 +8,7 @@ package big + + import ( + "encoding/binary" ++ "errors" + "fmt" + ) + +@@ -67,6 +68,9 @@ func (z *Float) GobDecode(buf []byte) error { + *z = Float{} + return nil + } ++ if len(buf) < 6 { ++ return errors.New("Float.GobDecode: buffer too small") ++ } + + if buf[0] != floatGobVersion { + return fmt.Errorf("Float.GobDecode: encoding version %d not supported", buf[0]) +@@ -83,6 +87,9 @@ func (z *Float) GobDecode(buf []byte) error { + z.prec = binary.BigEndian.Uint32(buf[2:]) + + if z.form == finite { ++ if len(buf) < 10 { ++ return errors.New("Float.GobDecode: buffer too small for finite form float") ++ } + z.exp = int32(binary.BigEndian.Uint32(buf[6:])) + z.mant = z.mant.setBytes(buf[10:]) + } +diff --git a/src/math/big/floatmarsh_test.go b/src/math/big/floatmarsh_test.go +index c056d78b80..401f45a51f 100644 +--- a/src/math/big/floatmarsh_test.go ++++ b/src/math/big/floatmarsh_test.go +@@ -137,3 +137,15 @@ func TestFloatJSONEncoding(t *testing.T) { + } + } + } ++ ++func TestFloatGobDecodeShortBuffer(t *testing.T) { ++ for _, tc := range [][]byte{ ++ []byte{0x1, 0x0, 0x0, 0x0}, ++ []byte{0x1, 0xfa, 0x0, 0x0, 0x0, 0x0}, ++ } { ++ err := NewFloat(0).GobDecode(tc) ++ if err == nil { ++ t.Error("expected GobDecode to return error for malformed input") ++ } ++ } ++} +diff --git a/src/math/big/ratmarsh.go b/src/math/big/ratmarsh.go +index fbc7b6002d..56102e845b 100644 +--- a/src/math/big/ratmarsh.go ++++ b/src/math/big/ratmarsh.go +@@ -45,12 +45,18 @@ func (z *Rat) GobDecode(buf []byte) error { + *z = Rat{} + return nil + } ++ if len(buf) < 5 { ++ return errors.New("Rat.GobDecode: buffer too small") ++ } + b := buf[0] + if b>>1 != ratGobVersion { + return fmt.Errorf("Rat.GobDecode: encoding version %d not supported", b>>1) + } + const j = 1 + 4 + i := j + binary.BigEndian.Uint32(buf[j-4:j]) ++ if len(buf) < int(i) { ++ return errors.New("Rat.GobDecode: buffer too small") ++ } + z.a.neg = b&1 != 0 + z.a.abs = z.a.abs.setBytes(buf[j:i]) + z.b.abs = z.b.abs.setBytes(buf[i:]) +diff --git a/src/math/big/ratmarsh_test.go b/src/math/big/ratmarsh_test.go +index 351d109f8d..55a9878bb8 100644 +--- a/src/math/big/ratmarsh_test.go ++++ b/src/math/big/ratmarsh_test.go +@@ -123,3 +123,15 @@ func TestRatXMLEncoding(t *testing.T) { + } + } + } ++ ++func TestRatGobDecodeShortBuffer(t *testing.T) { ++ for _, tc := range [][]byte{ ++ []byte{0x2}, ++ []byte{0x2, 0x0, 0x0, 0x0, 0xff}, ++ } { ++ err := NewRat(1, 2).GobDecode(tc) ++ if err == nil { ++ t.Error("expected GobDecode to return error for malformed input") ++ } ++ } ++} +-- +2.30.2 + diff --git a/0017-path-filepath-do-not-remove-prefix-.-when-following-.patch b/0017-path-filepath-do-not-remove-prefix-.-when-following-.patch new file mode 100644 index 0000000000000000000000000000000000000000..0f44f3850d75025e402eebca56b103c2e0751d04 --- /dev/null +++ b/0017-path-filepath-do-not-remove-prefix-.-when-following-.patch @@ -0,0 +1,103 @@ +From e903e474f9632a151fff2df3dd3e891395f1a8f1 Mon Sep 17 00:00:00 2001 +From: Yasuhiro Matsumoto +Date: Fri, 22 Apr 2022 10:07:51 +0900 +Subject: [PATCH 1/2] path/filepath: do not remove prefix "." when following + path contains ":". + +Fixes #52476 + +Change-Id: I9eb72ac7dbccd6322d060291f31831dc389eb9bb +Reviewed-on: https://go-review.googlesource.com/c/go/+/401595 +Auto-Submit: Ian Lance Taylor +Reviewed-by: Alex Brainman +Run-TryBot: Ian Lance Taylor +Reviewed-by: Ian Lance Taylor +Reviewed-by: Damien Neil +TryBot-Result: Gopher Robot + +Reference:https://go-review.googlesource.com/c/go/+/401595/ +Conflict:NA +--- + src/path/filepath/path.go | 14 +++++++++++++- + src/path/filepath/path_test.go | 3 +++ + src/path/filepath/path_windows_test.go | 26 ++++++++++++++++++++++++++ + 3 files changed, 42 insertions(+), 1 deletion(-) + +diff --git a/src/path/filepath/path.go b/src/path/filepath/path.go +index b56534dead..8300a32cb1 100644 +--- a/src/path/filepath/path.go ++++ b/src/path/filepath/path.go +@@ -117,9 +117,21 @@ func Clean(path string) string { + case os.IsPathSeparator(path[r]): + // empty path element + r++ +- case path[r] == '.' && (r+1 == n || os.IsPathSeparator(path[r+1])): ++ case path[r] == '.' && r+1 == n: + // . element + r++ ++ case path[r] == '.' && os.IsPathSeparator(path[r+1]): ++ // ./ element ++ r++ ++ ++ for r < len(path) && os.IsPathSeparator(path[r]) { ++ r++ ++ } ++ if out.w == 0 && volumeNameLen(path[r:]) > 0 { ++ // When joining prefix "." and an absolute path on Windows, ++ // the prefix should not be removed. ++ out.append('.') ++ } + case path[r] == '.' && path[r+1] == '.' && (r+2 == n || os.IsPathSeparator(path[r+2])): + // .. element: remove to last separator + r += 2 +diff --git a/src/path/filepath/path_test.go b/src/path/filepath/path_test.go +index bc5509b49c..ed17a8854d 100644 +--- a/src/path/filepath/path_test.go ++++ b/src/path/filepath/path_test.go +@@ -93,6 +93,9 @@ var wincleantests = []PathTest{ + {`//host/share/foo/../baz`, `\\host\share\baz`}, + {`\\a\b\..\c`, `\\a\b\c`}, + {`\\a\b`, `\\a\b`}, ++ {`.\c:`, `.\c:`}, ++ {`.\c:\foo`, `.\c:\foo`}, ++ {`.\c:foo`, `.\c:foo`}, + } + + func TestClean(t *testing.T) { +diff --git a/src/path/filepath/path_windows_test.go b/src/path/filepath/path_windows_test.go +index 76a459ac96..3edafb5a85 100644 +--- a/src/path/filepath/path_windows_test.go ++++ b/src/path/filepath/path_windows_test.go +@@ -530,3 +530,29 @@ func TestNTNamespaceSymlink(t *testing.T) { + t.Errorf(`EvalSymlinks(%q): got %q, want %q`, filelink, got, want) + } + } ++ ++func TestIssue52476(t *testing.T) { ++ tests := []struct { ++ lhs, rhs string ++ want string ++ }{ ++ {`..\.`, `C:`, `..\C:`}, ++ {`..`, `C:`, `..\C:`}, ++ {`.`, `:`, `:`}, ++ {`.`, `C:`, `.\C:`}, ++ {`.`, `C:/a/b/../c`, `.\C:\a\c`}, ++ {`.`, `\C:`, `.\C:`}, ++ {`C:\`, `.`, `C:\`}, ++ {`C:\`, `C:\`, `C:\C:`}, ++ {`C`, `:`, `C\:`}, ++ {`\.`, `C:`, `\C:`}, ++ {`\`, `C:`, `\C:`}, ++ } ++ ++ for _, test := range tests { ++ got := filepath.Join(test.lhs, test.rhs) ++ if got != test.want { ++ t.Errorf(`Join(%q, %q): got %q, want %q`, test.lhs, test.rhs, got, test.want) ++ } ++ } ++} +-- +2.30.2 + diff --git a/0018-release-branch.go1.17-syscall-check-correct-group-in.patch b/0018-release-branch.go1.17-syscall-check-correct-group-in.patch new file mode 100644 index 0000000000000000000000000000000000000000..23872111deb09ff6cf9b92db33cd86301899934d --- /dev/null +++ b/0018-release-branch.go1.17-syscall-check-correct-group-in.patch @@ -0,0 +1,53 @@ +From 66cff0cda766c1533373fabf3bc26fc3397e55d5 Mon Sep 17 00:00:00 2001 +From: Damien Neil +Date: Tue, 12 Apr 2022 13:38:17 -0700 +Subject: [PATCH 2/2] [release-branch.go1.17] syscall: check correct group in + Faccessat + +The Faccessat call checks the user, group, or other permission bits of a +file to see if the calling process can access it. The test to see if the +group permissions should be used was made with the wrong group id, using +the process's group id rather than the file's group id. Fix this to use +the correct group id. + +No test since we cannot easily change file permissions when not running +as root and the test is meaningless if running as root. + +For #52313 +Fixes #52439 + +Change-Id: I4e2c84754b0af7830b40fd15dedcbc58374d75ee +Reviewed-on: https://go-review.googlesource.com/c/go/+/399539 +Reviewed-by: Ian Lance Taylor +Run-TryBot: Ian Lance Taylor +TryBot-Result: Gopher Robot +(cherry picked from commit f66925e854e71e0c54b581885380a490d7afa30c) +Reviewed-on: https://go-review.googlesource.com/c/go/+/401078 +Auto-Submit: Tatiana Bradley +Run-TryBot: Tatiana Bradley +Run-TryBot: Damien Neil +Auto-Submit: Damien Neil +Reviewed-by: Tatiana Bradley + +Reference:https://go-review.googlesource.com/c/go/+/401078/ +Conflict:NA +--- + src/syscall/syscall_linux.go | 2 +- + 1 file changed, 1 insertion(+), 1 deletion(-) + +diff --git a/src/syscall/syscall_linux.go b/src/syscall/syscall_linux.go +index dfce3d0a4b..3387f3bdc2 100644 +--- a/src/syscall/syscall_linux.go ++++ b/src/syscall/syscall_linux.go +@@ -109,7 +109,7 @@ func Faccessat(dirfd int, path string, mode uint32, flags int) (err error) { + gid = Getgid() + } + +- if uint32(gid) == st.Gid || isGroupMember(gid) { ++ if uint32(gid) == st.Gid || isGroupMember(int(st.Gid)) { + fmode = (st.Mode >> 3) & 7 + } else { + fmode = st.Mode & 7 +-- +2.30.2 + diff --git a/go1.15.7.src.tar.gz b/go1.17.3.src.tar.gz similarity index 68% rename from go1.15.7.src.tar.gz rename to go1.17.3.src.tar.gz index aff1b44d465236814ec342f27071a13e894398a8..44c4f49fb37bd15237686ef83e5a0741e0e406df 100644 Binary files a/go1.15.7.src.tar.gz and b/go1.17.3.src.tar.gz differ diff --git a/golang.spec b/golang.spec index 82479efea1b554901d264ad847ca3d7b5da85d87..9ebf77ff306df10cbe12752f22b469bf3689cc7f 100644 --- a/golang.spec +++ b/golang.spec @@ -2,8 +2,8 @@ %global _binaries_in_noarch_packages_terminate_build 0 %global golibdir %{_libdir}/golang %global goroot /usr/lib/%{name} -%global go_api 1.15 -%global go_version 1.15 +%global go_api 1.17 +%global go_version 1.17 %global __spec_install_post /usr/lib/rpm/check-rpaths /usr/lib/rpm/check-buildroot /usr/lib/rpm/brp-compress %global __requires_exclude_from ^(%{_datadir}|/usr/lib)/%{name}/(doc|src)/.*$ %global __strip /bin/true @@ -65,12 +65,12 @@ Name: golang -Version: 1.15.7 -Release: 2 +Version: 1.17.3 +Release: 7 Summary: The Go Programming Language License: BSD and Public Domain URL: https://golang.org/ -Source0: https://dl.google.com/go/go1.15.7.src.tar.gz +Source0: https://dl.google.com/go/go1.17.3.src.tar.gz %if !%{golang_bootstrap} BuildRequires: gcc-go >= 5 @@ -153,15 +153,26 @@ Obsoletes: %{name}-vim < 1.4 Obsoletes: emacs-%{name} < 1.4 Requires: openEuler-rpm-config -ExclusiveArch: %{golang_arches} - -Patch1: riscv-support-external-linking.patch -Patch2: riscv-TLS-support.patch -Patch3: riscv-cmd-internal-move-rigisrter.patch -Patch4: riscv-go-runtime-add-support-cgo.patch -Patch5: riscv-enable-build-modes.patch - +Patch6001: 0001-release-branch.go1.17-crypto-elliptic-tolerate-zero-.patch +Patch6002: 0002-release-branch.go1.17-encoding-pem-fix-stack-overflo.patch +Patch6003: 0003-release-branch.go1.17-syscall-fix-ForkLock-spurious-.patch +Patch6004: 0004-backport-cmd-link-mark-unexported-methods-for-plugins.patch +Patch6005: 0005-release-branch.go1.17-net-http-preserve-nil-values-i.patch +Patch6006: 0006-release-branch.go1.17-go-parser-limit-recursion-dept.patch +Patch6007: 0007-release-branch.go1.17-net-http-don-t-strip-whitespac.patch +Patch6008: 0008-release-branch.go1.17-encoding-xml-limit-depth-of-ne.patch +Patch6009: 0009-release-branch.go1.17-encoding-gob-add-a-depth-limit.patch +Patch6010: 0010-release-branch.go1.17-io-fs-fix-stack-exhaustion-in-.patch +Patch6011: 0011-release-branch.go1.17-path-filepath-fix-stack-exhaus.patch +Patch6012: 0012-release-branch.go1.17-encoding-xml-use-iterative-Ski.patch +Patch6013: 0013-release-branch.go1.17-compress-gzip-fix-stack-exhaus.patch +Patch6014: 0014-release-branch.go1.17-crypto-tls-randomly-generate-t.patch +Patch6015: 0015-release-branch.go1.17-crypto-rand-properly-handle-la.patch +Patch6016: 0016-release-branch.go1.17-math-big-check-buffer-lengths-.patch +Patch6017: 0017-path-filepath-do-not-remove-prefix-.-when-following-.patch +Patch6018: 0018-release-branch.go1.17-syscall-check-correct-group-in.patch +ExclusiveArch: %{golang_arches} %description %{summary}. @@ -257,7 +268,7 @@ rm -rf pkg/obj/go-build/* mkdir -p %{buildroot}%{_bindir} mkdir -p %{buildroot}%{goroot} -cp -apv api bin doc favicon.ico lib pkg robots.txt src misc test VERSION \ +cp -apv api bin doc lib pkg src misc test VERSION \ %{buildroot}%{goroot} # bz1099206 @@ -394,47 +405,45 @@ fi %files devel -f go-tests.list -f go-misc.list -f go-src.list %changelog -* Thu Apr 15 2021 lixiang - 1.15.7-2 -- speed up build progress - -* Thu Jan 28 2021 xingweizheng - 1.15.7-1 -- upgrade to 1.15.7 - -* Mon Dec 7 2020 yangyanchao - 1.15.5-3 -- Enable Cgo for RISC-V - -* Sat Nov 28 2020 whoisxxx - 1.15.5-2 -- Adate for RISC-V - -* Wed Nov 18 2020 liuzekun - 1.15.5-1 -- upgrade to 1.15.5 - -* Tue Aug 18 2020 xiadanni - 1.13.15-1 -- upgrade to 1.13.15 - -* Fri Jul 31 2020 xiadanni - 1.13.14-2 -- add yaml file - -* Thu Jul 30 2020 xiadanni - 1.13.14-1 -- upgrade to 1.13.14 - -* Thu Jul 23 2020 xiadanni - 1.13-4.1 -- bump to 1.13.4 - -* Tue May 12 2020 lixiang - 1.13-3.6 -- rename tar name and make it same with upstream - -* Tue Mar 24 2020 jingrui - 1.13-3.5 -- drop hard code cert - -* Mon Mar 23 2020 jingrui - 1.13-3.4 -- fix CVE-2020-7919 - -* Thu Feb 20 2020 openEuler Buildteam - 1.13-3.2 -- requires remove mercurial - -* Tue Dec 10 2019 jingrui - 1.13-3.1 -- upgrade to golang 1.13.3 - -* Tue Sep 03 2019 leizhongkai - 1.11-1 -- backport fix CVE-2019-9512 and CVE-2019-9514 +* Thu Aug 18 2022 hanchao - 1.17.3-7 +- Type:CVE +- CVE:CVE-2022-29804,CVE-2022-29526 +- SUG:NA +- DESC: fix CVE-2022-29804,CVE-2022-29526 + +* Mon Aug 8 2022 hanchao - 1.17.3-6 +- Type:CVE +- CVE:NA +- SUG:NA +- DESC: fix CVE-2022-32189 + +* Tue Jul 26 2022 hanchao - 1.17.3-5 +- Type:CVE +- CVE:NA +- SUG:NA +- DESC: fix CVE-2022-32148,CVE-2022-1962,CVE-2022-1705,CVE-2022-30633, + CVE-2022-30635,CVE-2022-30630,CVE-2022-30632,CVE-2022-28131, + CVE-2022-30631,CVE-2022-30629,CVE-2022-30634 + +* Tue Jun 28 2022 Bin Hu - 1.17.3-4 +- Type:bugfix +- CVE:NA +- SUG:NA +- DESC:backport patch to fix bug of golang plugin mode + +* Fri May 6 2022 hanchao - 1.17.3-3 +- Type:CVE +- CVE:CVE-2021-44717 +- SUG:NA +- DESC:fix CVE-2021-44717 +- fix CVE-2021-44717 + +* Fri May 6 2022 hanchao - 1.17.3-2 +- Type:CVE +- CVE:CVE-2022-28327,CVE-2022-24675 +- SUG:NA +- DESC:fix CVE-2022-28327,CVE-2022-24675 +- fix CVE-2022-28327 CVE-2022-24675 + +* Mon Nov 29 2021 chenjiankun - 1.17.3-1 +- upgrade to 1.17.3 diff --git a/riscv-TLS-support.patch b/riscv-TLS-support.patch deleted file mode 100644 index ddca456825ff27e656538b02bd8fad577b83acfa..0000000000000000000000000000000000000000 --- a/riscv-TLS-support.patch +++ /dev/null @@ -1,206 +0,0 @@ -From 98d9c96b21ae096926575363091ec1fccfd6416e Mon Sep 17 00:00:00 2001 -From: Joel Sing -Date: Tue, 19 May 2020 18:55:10 +1000 -Subject: [PATCH] cmd/link,cmd/internal/obj/riscv: add TLS support for - linux/riscv64 - -Add support for Thread Local Storage (TLS) for linux/riscv64 with external -linking, using the initial-exec model. - -Change-Id: I3106ef9a29cde73215830b00deff43dbec1c76e0 ---- - src/cmd/internal/obj/riscv/obj.go | 7 +++ - src/cmd/internal/objabi/reloctype.go | 8 ++++ - src/cmd/internal/objabi/reloctype_string.go | 67 ++++++++++++++++++++++++++++- - src/cmd/link/internal/riscv64/asm.go | 15 +++++-- - src/cmd/link/link_test.go | 4 ++ - 5 files changed, 96 insertions(+), 5 deletions(-) - -diff --git a/src/cmd/internal/obj/riscv/obj.go b/src/cmd/internal/obj/riscv/obj.go -index 2eb2935..69c9a31 100644 ---- a/src/cmd/internal/obj/riscv/obj.go -+++ b/src/cmd/internal/obj/riscv/obj.go -@@ -1982,6 +1982,13 @@ func assemble(ctxt *obj.Link, cursym *obj.LSym, newprog obj.ProgAlloc) { - ctxt.Diag("AUIPC needing PC-relative reloc missing symbol") - break - } -+ if addr.Sym.Type == objabi.STLSBSS { -+ if rt == objabi.R_RISCV_PCREL_ITYPE { -+ rt = objabi.R_RISCV_TLS_IE_ITYPE -+ } else if rt == objabi.R_RISCV_PCREL_STYPE { -+ rt = objabi.R_RISCV_TLS_IE_STYPE -+ } -+ } - - rel := obj.Addrel(cursym) - rel.Off = int32(p.Pc) -diff --git a/src/cmd/internal/objabi/reloctype.go b/src/cmd/internal/objabi/reloctype.go -index f029a3c..b84abce 100644 ---- a/src/cmd/internal/objabi/reloctype.go -+++ b/src/cmd/internal/objabi/reloctype.go -@@ -212,6 +212,14 @@ const ( - // AUIPC + S-type instruction pair. - R_RISCV_PCREL_STYPE - -+ // R_RISCV_TLS_IE_ITYPE resolves a 32-bit TLS initial-exec TOC offset -+ // address using an AUIPC + I-type instruction pair. -+ R_RISCV_TLS_IE_ITYPE -+ -+ // R_RISCV_TLS_IE_STYPE resolves a 32-bit TLS initial-exec TOC offset -+ // address using an AUIPC + S-type instruction pair. -+ R_RISCV_TLS_IE_STYPE -+ - // R_PCRELDBL relocates s390x 2-byte aligned PC-relative addresses. - // TODO(mundaym): remove once variants can be serialized - see issue 14218. - R_PCRELDBL -diff --git a/src/cmd/internal/objabi/reloctype_string.go b/src/cmd/internal/objabi/reloctype_string.go -index 83dfe71..b9843fd 100644 ---- a/src/cmd/internal/objabi/reloctype_string.go -+++ b/src/cmd/internal/objabi/reloctype_string.go -@@ -4,9 +4,72 @@ package objabi - - import "strconv" - --const _RelocType_name = "R_ADDRR_ADDRPOWERR_ADDRARM64R_ADDRMIPSR_ADDROFFR_WEAKADDROFFR_SIZER_CALLR_CALLARMR_CALLARM64R_CALLINDR_CALLPOWERR_CALLMIPSR_CALLRISCVR_CONSTR_PCRELR_TLS_LER_TLS_IER_GOTOFFR_PLT0R_PLT1R_PLT2R_USEFIELDR_USETYPER_METHODOFFR_POWER_TOCR_GOTPCRELR_JMPMIPSR_DWARFSECREFR_DWARFFILEREFR_ARM64_TLS_LER_ARM64_TLS_IER_ARM64_GOTPCRELR_ARM64_GOTR_ARM64_PCRELR_ARM64_LDST8R_ARM64_LDST32R_ARM64_LDST64R_ARM64_LDST128R_POWER_TLS_LER_POWER_TLS_IER_POWER_TLSR_ADDRPOWER_DSR_ADDRPOWER_GOTR_ADDRPOWER_PCRELR_ADDRPOWER_TOCRELR_ADDRPOWER_TOCREL_DSR_RISCV_PCREL_ITYPER_RISCV_PCREL_STYPER_PCRELDBLR_ADDRMIPSUR_ADDRMIPSTLSR_ADDRCUOFFR_WASMIMPORTR_XCOFFREF" -+func _() { -+ // An "invalid array index" compiler error signifies that the constant values have changed. -+ // Re-run the stringer command to generate them again. -+ var x [1]struct{} -+ _ = x[R_ADDR-1] -+ _ = x[R_ADDRPOWER-2] -+ _ = x[R_ADDRARM64-3] -+ _ = x[R_ADDRMIPS-4] -+ _ = x[R_ADDROFF-5] -+ _ = x[R_WEAKADDROFF-6] -+ _ = x[R_SIZE-7] -+ _ = x[R_CALL-8] -+ _ = x[R_CALLARM-9] -+ _ = x[R_CALLARM64-10] -+ _ = x[R_CALLIND-11] -+ _ = x[R_CALLPOWER-12] -+ _ = x[R_CALLMIPS-13] -+ _ = x[R_CALLRISCV-14] -+ _ = x[R_CONST-15] -+ _ = x[R_PCREL-16] -+ _ = x[R_TLS_LE-17] -+ _ = x[R_TLS_IE-18] -+ _ = x[R_GOTOFF-19] -+ _ = x[R_PLT0-20] -+ _ = x[R_PLT1-21] -+ _ = x[R_PLT2-22] -+ _ = x[R_USEFIELD-23] -+ _ = x[R_USETYPE-24] -+ _ = x[R_METHODOFF-25] -+ _ = x[R_POWER_TOC-26] -+ _ = x[R_GOTPCREL-27] -+ _ = x[R_JMPMIPS-28] -+ _ = x[R_DWARFSECREF-29] -+ _ = x[R_DWARFFILEREF-30] -+ _ = x[R_ARM64_TLS_LE-31] -+ _ = x[R_ARM64_TLS_IE-32] -+ _ = x[R_ARM64_GOTPCREL-33] -+ _ = x[R_ARM64_GOT-34] -+ _ = x[R_ARM64_PCREL-35] -+ _ = x[R_ARM64_LDST8-36] -+ _ = x[R_ARM64_LDST32-37] -+ _ = x[R_ARM64_LDST64-38] -+ _ = x[R_ARM64_LDST128-39] -+ _ = x[R_POWER_TLS_LE-40] -+ _ = x[R_POWER_TLS_IE-41] -+ _ = x[R_POWER_TLS-42] -+ _ = x[R_ADDRPOWER_DS-43] -+ _ = x[R_ADDRPOWER_GOT-44] -+ _ = x[R_ADDRPOWER_PCREL-45] -+ _ = x[R_ADDRPOWER_TOCREL-46] -+ _ = x[R_ADDRPOWER_TOCREL_DS-47] -+ _ = x[R_RISCV_PCREL_ITYPE-48] -+ _ = x[R_RISCV_PCREL_STYPE-49] -+ _ = x[R_RISCV_TLS_IE_ITYPE-50] -+ _ = x[R_RISCV_TLS_IE_STYPE-51] -+ _ = x[R_PCRELDBL-52] -+ _ = x[R_ADDRMIPSU-53] -+ _ = x[R_ADDRMIPSTLS-54] -+ _ = x[R_ADDRCUOFF-55] -+ _ = x[R_WASMIMPORT-56] -+ _ = x[R_XCOFFREF-57] -+} -+ -+const _RelocType_name = "R_ADDRR_ADDRPOWERR_ADDRARM64R_ADDRMIPSR_ADDROFFR_WEAKADDROFFR_SIZER_CALLR_CALLARMR_CALLARM64R_CALLINDR_CALLPOWERR_CALLMIPSR_CALLRISCVR_CONSTR_PCRELR_TLS_LER_TLS_IER_GOTOFFR_PLT0R_PLT1R_PLT2R_USEFIELDR_USETYPER_METHODOFFR_POWER_TOCR_GOTPCRELR_JMPMIPSR_DWARFSECREFR_DWARFFILEREFR_ARM64_TLS_LER_ARM64_TLS_IER_ARM64_GOTPCRELR_ARM64_GOTR_ARM64_PCRELR_ARM64_LDST8R_ARM64_LDST32R_ARM64_LDST64R_ARM64_LDST128R_POWER_TLS_LER_POWER_TLS_IER_POWER_TLSR_ADDRPOWER_DSR_ADDRPOWER_GOTR_ADDRPOWER_PCRELR_ADDRPOWER_TOCRELR_ADDRPOWER_TOCREL_DSR_RISCV_PCREL_ITYPER_RISCV_PCREL_STYPER_RISCV_TLS_IE_ITYPER_RISCV_TLS_IE_STYPER_PCRELDBLR_ADDRMIPSUR_ADDRMIPSTLSR_ADDRCUOFFR_WASMIMPORTR_XCOFFREF" - --var _RelocType_index = [...]uint16{0, 6, 17, 28, 38, 47, 60, 66, 72, 81, 92, 101, 112, 122, 133, 140, 147, 155, 163, 171, 177, 183, 189, 199, 208, 219, 230, 240, 249, 262, 276, 290, 304, 320, 331, 344, 357, 371, 385, 400, 414, 428, 439, 453, 468, 485, 503, 524, 543, 562, 572, 583, 596, 607, 619, 629} -+var _RelocType_index = [...]uint16{0, 6, 17, 28, 38, 47, 60, 66, 72, 81, 92, 101, 112, 122, 133, 140, 147, 155, 163, 171, 177, 183, 189, 199, 208, 219, 230, 240, 249, 262, 276, 290, 304, 320, 331, 344, 357, 371, 385, 400, 414, 428, 439, 453, 468, 485, 503, 524, 543, 562, 582, 602, 612, 623, 636, 647, 659, 669} - - func (i RelocType) String() string { - i -= 1 -diff --git a/src/cmd/link/internal/riscv64/asm.go b/src/cmd/link/internal/riscv64/asm.go -index a3f19b2..7ed45d2 100644 ---- a/src/cmd/link/internal/riscv64/asm.go -+++ b/src/cmd/link/internal/riscv64/asm.go -@@ -67,7 +67,7 @@ func elfreloc1(ctxt *ld.Link, s *sym.Symbol, r *sym.Reloc, sectoff int64) bool { - // TODO(jsing): Consider generating elf.R_RISCV_CALL instead of a - // HI20/LO12_I pair. - -- case objabi.R_RISCV_PCREL_ITYPE, objabi.R_RISCV_PCREL_STYPE: -+ case objabi.R_RISCV_PCREL_ITYPE, objabi.R_RISCV_PCREL_STYPE, objabi.R_RISCV_TLS_IE_ITYPE, objabi.R_RISCV_TLS_IE_STYPE: - // Find the text symbol for the AUIPC instruction targeted - // by this relocation. - hi20Sym := findHI20Symbol(ctxt, s.Value+int64(r.Off)) -@@ -86,6 +86,10 @@ func elfreloc1(ctxt *ld.Link, s *sym.Symbol, r *sym.Reloc, sectoff int64) bool { - hiRel, loRel = elf.R_RISCV_PCREL_HI20, elf.R_RISCV_PCREL_LO12_I - case objabi.R_RISCV_PCREL_STYPE: - hiRel, loRel = elf.R_RISCV_PCREL_HI20, elf.R_RISCV_PCREL_LO12_S -+ case objabi.R_RISCV_TLS_IE_ITYPE: -+ hiRel, loRel = elf.R_RISCV_TLS_GOT_HI20, elf.R_RISCV_PCREL_LO12_I -+ case objabi.R_RISCV_TLS_IE_STYPE: -+ hiRel, loRel = elf.R_RISCV_TLS_GOT_HI20, elf.R_RISCV_PCREL_LO12_S - } - ctxt.Out.Write64(uint64(sectoff)) - ctxt.Out.Write64(uint64(hiRel) | uint64(elfsym)<<32) -@@ -119,7 +123,7 @@ func archreloc(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol - r.Xadd = r.Add - return val, true - -- case objabi.R_RISCV_PCREL_ITYPE, objabi.R_RISCV_PCREL_STYPE: -+ case objabi.R_RISCV_PCREL_ITYPE, objabi.R_RISCV_PCREL_STYPE, objabi.R_RISCV_TLS_IE_ITYPE, objabi.R_RISCV_TLS_IE_STYPE: - r.Done = false - - // Set up addend for eventual relocation via outer symbol. -@@ -146,6 +150,10 @@ func archreloc(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol - // Nothing to do. - return val, true - -+ case objabi.R_RISCV_TLS_IE_ITYPE, objabi.R_RISCV_TLS_IE_STYPE: -+ // Nothing to do. -+ return val, true -+ - case objabi.R_RISCV_PCREL_ITYPE, objabi.R_RISCV_PCREL_STYPE: - pc := s.Value + int64(r.Off) - off := ld.Symaddr(r.Sym) + r.Add - pc -@@ -202,7 +210,8 @@ func genHi20TextSymbols(ctxt *ld.Link) { - var syms []*sym.Symbol - for _, s := range ctxt.Textp { - for _, r := range s.R { -- if r.Type != objabi.R_RISCV_PCREL_ITYPE && r.Type != objabi.R_RISCV_PCREL_STYPE { -+ if r.Type != objabi.R_RISCV_PCREL_ITYPE && r.Type != objabi.R_RISCV_PCREL_STYPE && -+ r.Type != objabi.R_RISCV_TLS_IE_ITYPE && r.Type != objabi.R_RISCV_TLS_IE_STYPE { - continue - } - sym := &sym.Symbol{ -diff --git a/src/cmd/link/link_test.go b/src/cmd/link/link_test.go -index 8f417ec..3db2c15 100644 ---- a/src/cmd/link/link_test.go -+++ b/src/cmd/link/link_test.go -@@ -541,6 +541,10 @@ func TestOldLink(t *testing.T) { - - testenv.MustHaveGoBuild(t) - -+ if runtime.GOOS == "linux" && runtime.GOARCH == "riscv64" { -+ t.Skipf("skipping because oldlink does not handle TLS on linux/riscv64") -+ } -+ - // Check that the old linker exists (we don't ship it in binary releases, - // see issue 39509). - cmd := exec.Command(testenv.GoToolPath(t), "tool", "-n", "oldlink") --- -1.8.3.1 - diff --git a/riscv-cmd-internal-move-rigisrter.patch b/riscv-cmd-internal-move-rigisrter.patch deleted file mode 100644 index 26a3583ce552f54446423950a1ed23299a7d117c..0000000000000000000000000000000000000000 --- a/riscv-cmd-internal-move-rigisrter.patch +++ /dev/null @@ -1,1073 +0,0 @@ -From 70ca9a801164e370cc6adf443d40a95c24143400 Mon Sep 17 00:00:00 2001 -From: Joel Sing -Date: Tue, 19 May 2020 18:55:31 +1000 -Subject: [PATCH] cmd/compile,cmd/internal/obj/riscv: move g register on - riscv64 - -The original riscv64 port used the thread pointer (TP aka X4) register for -the g pointer, however this register is also used when TLS support is -required, resulting in a conflict (for example, when a signal is received -we have no way of readily knowing if X4 contains a pointer to the TCB or -a pointer to a g). - -In order to support cgo, free up the X4 register by moving g to X27. -This unfortunately means that the X4 register is unused in non-cgo mode, -however the alternative is to not support cgo on this platform. - -Change-Id: Idcaf3e8ccbe42972a1b8943aeefde7149d9c960a ---- - src/cmd/compile/internal/ssa/gen/RISCV64Ops.go | 7 +- - src/cmd/compile/internal/ssa/opGen.go | 312 ++++++++++++------------- - src/cmd/internal/obj/riscv/cpu.go | 12 +- - 3 files changed, 166 insertions(+), 165 deletions(-) - -diff --git a/src/cmd/compile/internal/ssa/gen/RISCV64Ops.go b/src/cmd/compile/internal/ssa/gen/RISCV64Ops.go -index 8ab4abe..e83e865 100644 ---- a/src/cmd/compile/internal/ssa/gen/RISCV64Ops.go -+++ b/src/cmd/compile/internal/ssa/gen/RISCV64Ops.go -@@ -24,10 +24,11 @@ import ( - // L = 64 bit int, used when the opcode starts with F - - const ( -- riscv64REG_G = 4 -+ riscv64REG_G = 27 - riscv64REG_CTXT = 20 - riscv64REG_LR = 1 - riscv64REG_SP = 2 -+ riscv64REG_TP = 4 - riscv64REG_TMP = 31 - riscv64REG_ZERO = 0 - ) -@@ -78,8 +79,8 @@ func init() { - - // Add general purpose registers to gpMask. - switch r { -- // ZERO, and TMP are not in any gp mask. -- case riscv64REG_ZERO, riscv64REG_TMP: -+ // ZERO, TP and TMP are not in any gp mask. -+ case riscv64REG_ZERO, riscv64REG_TP, riscv64REG_TMP: - case riscv64REG_G: - gpgMask |= mask - gpspsbgMask |= mask -diff --git a/src/cmd/compile/internal/ssa/opGen.go b/src/cmd/compile/internal/ssa/opGen.go -index 9efa1bf..f3518dd 100644 ---- a/src/cmd/compile/internal/ssa/opGen.go -+++ b/src/cmd/compile/internal/ssa/opGen.go -@@ -26962,11 +26962,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AADD, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -26977,10 +26977,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AADDI, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 SB -+ {0, 9223372037861408758}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 SB - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27030,11 +27030,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.ASUB, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27059,11 +27059,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMUL, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27074,11 +27074,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMULW, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27089,11 +27089,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMULH, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27104,11 +27104,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMULHU, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27118,11 +27118,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.ADIV, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27132,11 +27132,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.ADIVU, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27146,11 +27146,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.ADIVW, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27160,11 +27160,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.ADIVUW, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27174,11 +27174,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AREM, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27188,11 +27188,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AREMU, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27202,11 +27202,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AREMW, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27216,11 +27216,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AREMUW, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27233,10 +27233,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOV, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 SB -+ {0, 9223372037861408758}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 SB - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27248,7 +27248,7 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOV, - reg: regInfo{ - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27260,7 +27260,7 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOV, - reg: regInfo{ - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27272,7 +27272,7 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOV, - reg: regInfo{ - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27284,7 +27284,7 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOV, - reg: regInfo{ - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27297,10 +27297,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOVB, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 SB -+ {0, 9223372037861408758}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 SB - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27313,10 +27313,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOVH, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 SB -+ {0, 9223372037861408758}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 SB - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27329,10 +27329,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOVW, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 SB -+ {0, 9223372037861408758}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 SB - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27345,10 +27345,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOV, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 SB -+ {0, 9223372037861408758}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 SB - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27361,10 +27361,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOVBU, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 SB -+ {0, 9223372037861408758}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 SB - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27377,10 +27377,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOVHU, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 SB -+ {0, 9223372037861408758}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 SB - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27393,10 +27393,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOVWU, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 SB -+ {0, 9223372037861408758}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 SB - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27409,8 +27409,8 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOVB, - reg: regInfo{ - inputs: []inputInfo{ -- {1, 1073741814}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 SB -+ {1, 1006632950}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {0, 9223372037861408758}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 SB - }, - }, - }, -@@ -27423,8 +27423,8 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOVH, - reg: regInfo{ - inputs: []inputInfo{ -- {1, 1073741814}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 SB -+ {1, 1006632950}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {0, 9223372037861408758}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 SB - }, - }, - }, -@@ -27437,8 +27437,8 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOVW, - reg: regInfo{ - inputs: []inputInfo{ -- {1, 1073741814}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 SB -+ {1, 1006632950}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {0, 9223372037861408758}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 SB - }, - }, - }, -@@ -27451,8 +27451,8 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOV, - reg: regInfo{ - inputs: []inputInfo{ -- {1, 1073741814}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 SB -+ {1, 1006632950}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {0, 9223372037861408758}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 SB - }, - }, - }, -@@ -27514,11 +27514,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.ASLL, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27528,11 +27528,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.ASRA, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27542,11 +27542,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.ASRL, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27557,10 +27557,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.ASLLI, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27571,10 +27571,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.ASRAI, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27585,10 +27585,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.ASRLI, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27599,11 +27599,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AXOR, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27614,10 +27614,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AXORI, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27628,11 +27628,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AOR, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27643,10 +27643,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AORI, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27657,11 +27657,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AAND, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27672,10 +27672,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AANDI, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27698,10 +27698,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.ASEQZ, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27711,10 +27711,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.ASNEZ, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27724,11 +27724,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.ASLT, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27739,10 +27739,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.ASLTI, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27752,11 +27752,11 @@ var opcodeTable = [...]opInfo{ - asm: riscv.ASLTU, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27767,10 +27767,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.ASLTIU, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27780,10 +27780,10 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOV, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -27794,7 +27794,7 @@ var opcodeTable = [...]opInfo{ - call: true, - symEffect: SymNone, - reg: regInfo{ -- clobbers: 9223372035781033980, // X3 g X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 -+ clobbers: 9223372035781033972, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 g X28 X29 X30 F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 - }, - }, - { -@@ -27805,9 +27805,9 @@ var opcodeTable = [...]opInfo{ - reg: regInfo{ - inputs: []inputInfo{ - {1, 524288}, // X20 -- {0, 1073741814}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632950}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, -- clobbers: 9223372035781033980, // X3 g X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 -+ clobbers: 9223372035781033972, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 g X28 X29 X30 F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 - }, - }, - { -@@ -27817,9 +27817,9 @@ var opcodeTable = [...]opInfo{ - call: true, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, -- clobbers: 9223372035781033980, // X3 g X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 -+ clobbers: 9223372035781033972, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 g X28 X29 X30 F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 - }, - }, - { -@@ -27830,7 +27830,7 @@ var opcodeTable = [...]opInfo{ - reg: regInfo{ - inputs: []inputInfo{ - {0, 16}, // X5 -- {1, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {1, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - clobbers: 16, // X5 - }, -@@ -27845,7 +27845,7 @@ var opcodeTable = [...]opInfo{ - inputs: []inputInfo{ - {0, 16}, // X5 - {1, 32}, // X6 -- {2, 1073741748}, // X3 X5 X6 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {2, 1006632884}, // X3 X5 X6 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - clobbers: 112, // X5 X6 X7 - }, -@@ -28034,7 +28034,7 @@ var opcodeTable = [...]opInfo{ - faultOnNilArg0: true, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741814}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632950}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -28053,7 +28053,7 @@ var opcodeTable = [...]opInfo{ - rematerializeable: true, - reg: regInfo{ - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -28063,7 +28063,7 @@ var opcodeTable = [...]opInfo{ - rematerializeable: true, - reg: regInfo{ - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -28207,7 +28207,7 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AFMVSX, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ - {0, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 -@@ -28220,7 +28220,7 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AFCVTSW, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ - {0, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 -@@ -28233,7 +28233,7 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AFCVTSL, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ - {0, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 -@@ -28249,7 +28249,7 @@ var opcodeTable = [...]opInfo{ - {0, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -28262,7 +28262,7 @@ var opcodeTable = [...]opInfo{ - {0, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -28275,7 +28275,7 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOVF, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 SB -+ {0, 9223372037861408758}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 SB - }, - outputs: []outputInfo{ - {0, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 -@@ -28291,7 +28291,7 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOVF, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 SB -+ {0, 9223372037861408758}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 SB - {1, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 - }, - }, -@@ -28307,7 +28307,7 @@ var opcodeTable = [...]opInfo{ - {1, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -28322,7 +28322,7 @@ var opcodeTable = [...]opInfo{ - {1, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -28336,7 +28336,7 @@ var opcodeTable = [...]opInfo{ - {1, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -28350,7 +28350,7 @@ var opcodeTable = [...]opInfo{ - {1, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -28444,7 +28444,7 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AFMVDX, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ - {0, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 -@@ -28457,7 +28457,7 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AFCVTDW, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ - {0, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 -@@ -28470,7 +28470,7 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AFCVTDL, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - outputs: []outputInfo{ - {0, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 -@@ -28486,7 +28486,7 @@ var opcodeTable = [...]opInfo{ - {0, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -28499,7 +28499,7 @@ var opcodeTable = [...]opInfo{ - {0, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -28538,7 +28538,7 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOVD, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 SB -+ {0, 9223372037861408758}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 SB - }, - outputs: []outputInfo{ - {0, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 -@@ -28554,7 +28554,7 @@ var opcodeTable = [...]opInfo{ - asm: riscv.AMOVD, - reg: regInfo{ - inputs: []inputInfo{ -- {0, 9223372037928517622}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 SB -+ {0, 9223372037861408758}, // SP X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 SB - {1, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 - }, - }, -@@ -28570,7 +28570,7 @@ var opcodeTable = [...]opInfo{ - {1, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -28585,7 +28585,7 @@ var opcodeTable = [...]opInfo{ - {1, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -28599,7 +28599,7 @@ var opcodeTable = [...]opInfo{ - {1, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -28613,7 +28613,7 @@ var opcodeTable = [...]opInfo{ - {1, 9223372034707292160}, // F0 F1 F2 F3 F4 F5 F6 F7 F8 F9 F10 F11 F12 F13 F14 F15 F16 F17 F18 F19 F20 F21 F22 F23 F24 F25 F26 F27 F28 F29 F30 F31 - }, - outputs: []outputInfo{ -- {0, 1073741812}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X27 X28 X29 X30 -+ {0, 1006632948}, // X3 X5 X6 X7 X8 X9 X10 X11 X12 X13 X14 X15 X16 X17 X18 X19 X20 X21 X22 X23 X24 X25 X26 X28 X29 X30 - }, - }, - }, -@@ -35809,7 +35809,7 @@ var registersRISCV64 = [...]Register{ - {0, riscv.REG_X0, -1, "X0"}, - {1, riscv.REGSP, -1, "SP"}, - {2, riscv.REG_X3, 0, "X3"}, -- {3, riscv.REGG, -1, "g"}, -+ {3, riscv.REG_X4, -1, "X4"}, - {4, riscv.REG_X5, 1, "X5"}, - {5, riscv.REG_X6, 2, "X6"}, - {6, riscv.REG_X7, 3, "X7"}, -@@ -35832,10 +35832,10 @@ var registersRISCV64 = [...]Register{ - {23, riscv.REG_X24, 20, "X24"}, - {24, riscv.REG_X25, 21, "X25"}, - {25, riscv.REG_X26, 22, "X26"}, -- {26, riscv.REG_X27, 23, "X27"}, -- {27, riscv.REG_X28, 24, "X28"}, -- {28, riscv.REG_X29, 25, "X29"}, -- {29, riscv.REG_X30, 26, "X30"}, -+ {26, riscv.REGG, -1, "g"}, -+ {27, riscv.REG_X28, 23, "X28"}, -+ {28, riscv.REG_X29, 24, "X29"}, -+ {29, riscv.REG_X30, 25, "X30"}, - {30, riscv.REG_X31, -1, "X31"}, - {31, riscv.REG_F0, -1, "F0"}, - {32, riscv.REG_F1, -1, "F1"}, -@@ -35871,7 +35871,7 @@ var registersRISCV64 = [...]Register{ - {62, riscv.REG_F31, -1, "F31"}, - {63, 0, -1, "SB"}, - } --var gpRegMaskRISCV64 = regMask(1073741812) -+var gpRegMaskRISCV64 = regMask(1006632948) - var fpRegMaskRISCV64 = regMask(9223372034707292160) - var specialRegMaskRISCV64 = regMask(0) - var framepointerRegRISCV64 = int8(-1) -diff --git a/src/cmd/internal/obj/riscv/cpu.go b/src/cmd/internal/obj/riscv/cpu.go -index 482f9e0..b1324b6 100644 ---- a/src/cmd/internal/obj/riscv/cpu.go -+++ b/src/cmd/internal/obj/riscv/cpu.go -@@ -109,7 +109,7 @@ const ( - REG_RA = REG_X1 // aka REG_LR - REG_SP = REG_X2 - REG_GP = REG_X3 // aka REG_SB -- REG_TP = REG_X4 // aka REG_G -+ REG_TP = REG_X4 - REG_T0 = REG_X5 - REG_T1 = REG_X6 - REG_T2 = REG_X7 -@@ -132,17 +132,17 @@ const ( - REG_S8 = REG_X24 - REG_S9 = REG_X25 - REG_S10 = REG_X26 -- REG_S11 = REG_X27 -+ REG_S11 = REG_X27 // aka REG_G - REG_T3 = REG_X28 - REG_T4 = REG_X29 - REG_T5 = REG_X30 - REG_T6 = REG_X31 // aka REG_TMP - - // Go runtime register names. -- REG_G = REG_TP // G pointer. -- REG_CTXT = REG_S4 // Context for closures. -- REG_LR = REG_RA // Link register. -- REG_TMP = REG_T6 // Reserved for assembler use. -+ REG_G = REG_S11 // G pointer. -+ REG_CTXT = REG_S4 // Context for closures. -+ REG_LR = REG_RA // Link register. -+ REG_TMP = REG_T6 // Reserved for assembler use. - - // ABI names for floating point registers. - REG_FT0 = REG_F0 --- -1.8.3.1 - diff --git a/riscv-enable-build-modes.patch b/riscv-enable-build-modes.patch deleted file mode 100644 index 1aa7f9ebef736838d984e3e63c59f248f1dd8899..0000000000000000000000000000000000000000 --- a/riscv-enable-build-modes.patch +++ /dev/null @@ -1,81 +0,0 @@ -From ba41f5960408a58339e6efb1bf379031cc35efeb Mon Sep 17 00:00:00 2001 -From: Joel Sing -Date: Tue, 2 Jun 2020 23:34:06 +1000 -Subject: [PATCH] cmd/compile,cmd/internal/sys: enable non-exe build modes on - linux/riscv64 - -Change-Id: I15a8a51b84dbbb82a5b6592aec84a7f09f0cc37f ---- - src/cmd/compile/internal/gc/main.go | 2 +- - src/cmd/go/go_test.go | 2 +- - src/cmd/internal/sys/supported.go | 8 ++++---- - 3 files changed, 6 insertions(+), 6 deletions(-) - -diff --git a/src/cmd/compile/internal/gc/main.go b/src/cmd/compile/internal/gc/main.go -index 756cdbd..34997f4 100644 ---- a/src/cmd/compile/internal/gc/main.go -+++ b/src/cmd/compile/internal/gc/main.go -@@ -132,7 +132,7 @@ func hidePanic() { - // supportsDynlink reports whether or not the code generator for the given - // architecture supports the -shared and -dynlink flags. - func supportsDynlink(arch *sys.Arch) bool { -- return arch.InFamily(sys.AMD64, sys.ARM, sys.ARM64, sys.I386, sys.PPC64, sys.S390X) -+ return arch.InFamily(sys.AMD64, sys.ARM, sys.ARM64, sys.I386, sys.PPC64, sys.RISCV64, sys.S390X) - } - - // timing data for compiler phases -diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go -index 021930a..8093341 100644 ---- a/src/cmd/go/go_test.go -+++ b/src/cmd/go/go_test.go -@@ -2058,7 +2058,7 @@ func TestBuildmodePIE(t *testing.T) { - - platform := fmt.Sprintf("%s/%s", runtime.GOOS, runtime.GOARCH) - switch platform { -- case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/ppc64le", "linux/s390x", -+ case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/ppc64le", "linux/riscv64", "linux/s390x", - "android/amd64", "android/arm", "android/arm64", "android/386", - "freebsd/amd64", - "windows/386", "windows/amd64", "windows/arm": -diff --git a/src/cmd/internal/sys/supported.go b/src/cmd/internal/sys/supported.go -index c27b3b9..527f739 100644 ---- a/src/cmd/internal/sys/supported.go -+++ b/src/cmd/internal/sys/supported.go -@@ -66,7 +66,7 @@ func BuildModeSupported(compiler, buildmode, goos, goarch string) bool { - - case "c-shared": - switch platform { -- case "linux/amd64", "linux/arm", "linux/arm64", "linux/386", "linux/ppc64le", "linux/s390x", -+ case "linux/amd64", "linux/arm", "linux/arm64", "linux/386", "linux/ppc64le", "linux/riscv64", "linux/s390x", - "android/amd64", "android/arm", "android/arm64", "android/386", - "freebsd/amd64", - "darwin/amd64", -@@ -83,7 +83,7 @@ func BuildModeSupported(compiler, buildmode, goos, goarch string) bool { - - case "pie": - switch platform { -- case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/ppc64le", "linux/s390x", -+ case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/ppc64le", "linux/riscv64", "linux/s390x", - "android/amd64", "android/arm", "android/arm64", "android/386", - "freebsd/amd64", - "darwin/amd64", -@@ -95,14 +95,14 @@ func BuildModeSupported(compiler, buildmode, goos, goarch string) bool { - - case "shared": - switch platform { -- case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/ppc64le", "linux/s390x": -+ case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/ppc64le", "linux/riscv64", "linux/s390x": - return true - } - return false - - case "plugin": - switch platform { -- case "linux/amd64", "linux/arm", "linux/arm64", "linux/386", "linux/s390x", "linux/ppc64le", -+ case "linux/amd64", "linux/arm", "linux/arm64", "linux/386", "linux/s390x", "linux/riscv64", "linux/ppc64le", - "android/amd64", "android/arm", "android/arm64", "android/386", - "darwin/amd64", - "freebsd/amd64": --- -1.8.3.1 - diff --git a/riscv-go-runtime-add-support-cgo.patch b/riscv-go-runtime-add-support-cgo.patch deleted file mode 100644 index 9be6790e82bcb52976ff1601dc1184cb47b31ac0..0000000000000000000000000000000000000000 --- a/riscv-go-runtime-add-support-cgo.patch +++ /dev/null @@ -1,710 +0,0 @@ -From 1f76e888dfcc67159b012c503ed2961691e0cf85 Mon Sep 17 00:00:00 2001 -From: Joel Sing -Date: Tue, 19 May 2020 18:56:01 +1000 -Subject: [PATCH] cmd/dist,cmd/go,runtime: add support for cgo on linux/riscv64 - -Change-Id: I51868d83ce341d78d33b221d184c5a5110c60d14 ---- - misc/cgo/test/testdata/issue9400/asm_riscv64.s | 33 ++++ - src/cmd/dist/build.go | 2 +- - src/cmd/dist/test.go | 2 +- - .../go/testdata/script/build_plugin_non_main.txt | 3 +- - src/cmd/nm/nm_cgo_test.go | 2 +- - src/runtime/asm_riscv64.s | 209 +++++++++++++++++++-- - src/runtime/cgo/asm_riscv64.s | 88 +++++++++ - src/runtime/cgo/gcc_linux_riscv64.c | 78 ++++++++ - src/runtime/cgo/gcc_riscv64.S | 87 +++++++++ - src/runtime/cgocall.go | 6 +- - src/runtime/sys_linux_riscv64.s | 5 + - src/runtime/tls_riscv64.s | 16 +- - 12 files changed, 512 insertions(+), 19 deletions(-) - create mode 100644 misc/cgo/test/testdata/issue9400/asm_riscv64.s - create mode 100644 src/runtime/cgo/asm_riscv64.s - create mode 100644 src/runtime/cgo/gcc_linux_riscv64.c - create mode 100644 src/runtime/cgo/gcc_riscv64.S - -diff --git a/misc/cgo/test/testdata/issue9400/asm_riscv64.s b/misc/cgo/test/testdata/issue9400/asm_riscv64.s -new file mode 100644 -index 0000000..772050d ---- /dev/null -+++ b/misc/cgo/test/testdata/issue9400/asm_riscv64.s -@@ -0,0 +1,33 @@ -+// 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. -+ -+// +build riscv64 -+// +build !gccgo -+ -+#include "textflag.h" -+ -+#define FENCE WORD $0x0ff0000f -+ -+TEXT ·RewindAndSetgid(SB),NOSPLIT|NOFRAME,$0-0 -+ // Rewind stack pointer so anything that happens on the stack -+ // will clobber the test pattern created by the caller -+ ADD $(1024*8), X2 -+ -+ // Ask signaller to setgid -+ MOV $1, X5 -+ FENCE -+ MOVW X5, ·Baton(SB) -+ FENCE -+ -+ // Wait for setgid completion -+loop: -+ FENCE -+ MOVW ·Baton(SB), X5 -+ OR X6, X6, X6 // hint that we're in a spin loop -+ BNE ZERO, X5, loop -+ FENCE -+ -+ // Restore stack -+ ADD $(-1024*8), X2 -+ RET -diff --git a/src/cmd/dist/build.go b/src/cmd/dist/build.go -index 9e2b4f3..5caa6e3 100644 ---- a/src/cmd/dist/build.go -+++ b/src/cmd/dist/build.go -@@ -1533,7 +1533,7 @@ var cgoEnabled = map[string]bool{ - "linux/mipsle": true, - "linux/mips64": true, - "linux/mips64le": true, -- "linux/riscv64": false, // Issue 36641 -+ "linux/riscv64": true, - "linux/s390x": true, - "linux/sparc64": true, - "android/386": true, -diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go -index 2dc9459..d07042f 100644 ---- a/src/cmd/dist/test.go -+++ b/src/cmd/dist/test.go -@@ -947,7 +947,7 @@ func (t *tester) internalLink() bool { - // Internally linking cgo is incomplete on some architectures. - // https://golang.org/issue/10373 - // https://golang.org/issue/14449 -- if goarch == "mips64" || goarch == "mips64le" || goarch == "mips" || goarch == "mipsle" { -+ if goarch == "mips64" || goarch == "mips64le" || goarch == "mips" || goarch == "mipsle" || goarch == "riscv64" { - return false - } - if goos == "aix" { -diff --git a/src/cmd/go/testdata/script/build_plugin_non_main.txt b/src/cmd/go/testdata/script/build_plugin_non_main.txt -index 996d87d..1d561e8 100644 ---- a/src/cmd/go/testdata/script/build_plugin_non_main.txt -+++ b/src/cmd/go/testdata/script/build_plugin_non_main.txt -@@ -1,5 +1,6 @@ --# Plugins are only supported on linux,cgo and darwin,cgo. -+# Plugins are only supported on linux,cgo (!riscv64) and darwin,cgo. - [!linux] [!darwin] skip -+[linux] [riscv64] skip - [!cgo] skip - - go build -n testdep/p2 -diff --git a/src/cmd/nm/nm_cgo_test.go b/src/cmd/nm/nm_cgo_test.go -index 9a257e0..e0414e6 100644 ---- a/src/cmd/nm/nm_cgo_test.go -+++ b/src/cmd/nm/nm_cgo_test.go -@@ -24,7 +24,7 @@ func canInternalLink() bool { - } - case "linux": - switch runtime.GOARCH { -- case "arm64", "mips64", "mips64le", "mips", "mipsle", "ppc64", "ppc64le": -+ case "arm64", "mips64", "mips64le", "mips", "mipsle", "ppc64", "ppc64le", "riscv64": - return false - } - case "openbsd": -diff --git a/src/runtime/asm_riscv64.s b/src/runtime/asm_riscv64.s -index d7c45a1..fd5c4ca 100644 ---- a/src/runtime/asm_riscv64.s -+++ b/src/runtime/asm_riscv64.s -@@ -9,10 +9,9 @@ - // func rt0_go() - TEXT runtime·rt0_go(SB),NOSPLIT,$0 - // X2 = stack; A0 = argc; A1 = argv -- - ADD $-24, X2 -- MOV A0, 8(X2) // argc -- MOV A1, 16(X2) // argv -+ MOV A0, 8(X2) // argc -+ MOV A1, 16(X2) // argv - - // create istack out of the given (operating system) stack. - // _cgo_init may update stackguard. -@@ -28,10 +27,10 @@ TEXT runtime·rt0_go(SB),NOSPLIT,$0 - MOV _cgo_init(SB), T0 - BEQ T0, ZERO, nocgo - -- MOV ZERO, A3 // arg 3: not used -- MOV ZERO, A2 // arg 2: not used -+ MOV ZERO, A3 // arg 3: not used -+ MOV ZERO, A2 // arg 2: not used - MOV $setg_gcc<>(SB), A1 // arg 1: setg -- MOV g, A0 // arg 0: G -+ MOV g, A0 // arg 0: G - JALR RA, T0 - - nocgo: -@@ -313,10 +312,78 @@ TEXT runtime·gosave(SB), NOSPLIT|NOFRAME, $0-8 - CALL runtime·badctxt(SB) - RET - -+// Save state of caller into g->sched. Smashes X31. -+TEXT gosave<>(SB),NOSPLIT|NOFRAME,$0 -+ MOV X1, (g_sched+gobuf_pc)(g) -+ MOV X2, (g_sched+gobuf_sp)(g) -+ MOV ZERO, (g_sched+gobuf_lr)(g) -+ MOV ZERO, (g_sched+gobuf_ret)(g) -+ // Assert ctxt is zero. See func save. -+ MOV (g_sched+gobuf_ctxt)(g), X31 -+ BEQ ZERO, X31, 2(PC) -+ CALL runtime·badctxt(SB) -+ RET -+ - // func asmcgocall(fn, arg unsafe.Pointer) int32 -+// Call fn(arg) on the scheduler stack, -+// aligned appropriately for the gcc ABI. -+// See cgocall.go for more details. - TEXT ·asmcgocall(SB),NOSPLIT,$0-20 -- // TODO(jsing): Add support for cgo - issue #36641. -- WORD $0 // crash -+ MOV fn+0(FP), X5 -+ MOV arg+8(FP), X10 -+ -+ MOV X2, X8 // save original stack pointer -+ MOV g, X9 -+ -+ // Figure out if we need to switch to m->g0 stack. -+ // We get called to create new OS threads too, and those -+ // come in on the m->g0 stack already. -+ MOV g_m(g), X6 -+ MOV m_g0(X6), X7 -+ BEQ X7, g, g0 -+ -+ CALL gosave<>(SB) -+ MOV X7, g -+ CALL runtime·save_g(SB) -+ MOV (g_sched+gobuf_sp)(g), X2 -+ -+ // Now on a scheduling stack (a pthread-created stack). -+g0: -+ // Save room for two of our pointers. -+ ADD $-16, X2 -+ MOV X9, 0(X2) // save old g on stack -+ MOV (g_stack+stack_hi)(X9), X9 -+ SUB X8, X9, X8 -+ MOV X8, 8(X2) // save depth in old g stack (can't just save SP, as stack might be copied during a callback) -+ -+ JALR RA, (X5) -+ -+ // Restore g, stack pointer. X10 is return value. -+ MOV 0(X2), g -+ CALL runtime·save_g(SB) -+ MOV (g_stack+stack_hi)(g), X5 -+ MOV 8(X2), X6 -+ SUB X6, X5, X6 -+ MOV X6, X2 -+ -+ MOVW X10, ret+16(FP) -+ RET -+ -+// cgocallback(void (*fn)(void*), void *frame, uintptr framesize, uintptr ctxt) -+// Turn the fn into a Go func (by taking its address) and call -+// cgocallback_gofunc. -+TEXT runtime·cgocallback(SB),NOSPLIT,$32-32 -+ MOV $fn+0(FP), X5 -+ MOV X5, 8(SP) -+ MOV frame+8(FP), X5 -+ MOV X5, 16(SP) -+ MOV framesize+16(FP), X5 -+ MOV X5, 24(SP) -+ MOV ctxt+24(FP), X5 -+ MOV X5, 32(SP) -+ MOV $runtime·cgocallback_gofunc(SB), X5 -+ JALR RA, X5 -+ RET - - // func asminit() - TEXT runtime·asminit(SB),NOSPLIT|NOFRAME,$0-0 -@@ -443,6 +510,23 @@ CALLFN(·call268435456, 268435456) - CALLFN(·call536870912, 536870912) - CALLFN(·call1073741824, 1073741824) - -+// Called from cgo wrappers, this function returns g->m->curg.stack.hi. -+// Must obey the gcc calling convention. -+TEXT _cgo_topofstack(SB),NOSPLIT,$16 -+ // g (X30) and REG_TMP (X31) might be clobbered by load_g. They -+ // are callee-save in the gcc calling convention, so save them. -+ MOV X31, savedX31-16(SP) -+ MOV g, savedG-8(SP) -+ -+ CALL runtime·load_g(SB) -+ MOV g_m(g), X5 -+ MOV m_curg(X5), X5 -+ MOV (g_stack+stack_hi)(X5), X10 // return value in X10 -+ -+ MOV savedG-8(SP), g -+ MOV savedX31-16(SP), X31 -+ RET -+ - // func goexit(neverCallThisFunction) - // The top-most function running on a goroutine - // returns to goexit+PCQuantum. -@@ -452,10 +536,111 @@ TEXT runtime·goexit(SB),NOSPLIT|NOFRAME|TOPFRAME,$0-0 - // traceback from goexit1 must hit code range of goexit - MOV ZERO, ZERO // NOP - --// func cgocallback_gofunc(fv uintptr, frame uintptr, framesize, ctxt uintptr) --TEXT ·cgocallback_gofunc(SB),NOSPLIT,$24-32 -- // TODO(jsing): Add support for cgo - issue #36641. -- WORD $0 // crash -+// cgocallback_gofunc(FuncVal*, void *frame, uintptr framesize, uintptr ctxt) -+// See cgocall.go for more details. -+TEXT ·cgocallback_gofunc(SB),NOSPLIT,$16-32 -+ NO_LOCAL_POINTERS -+ -+ // Load m and g from thread-local storage. -+ MOVBU runtime·iscgo(SB), X5 -+ BEQ ZERO, X5, nocgo -+ CALL runtime·load_g(SB) -+nocgo: -+ -+ // If g is nil, Go did not create the current thread. -+ // Call needm to obtain one for temporary use. -+ // In this case, we're running on the thread stack, so there's -+ // lots of space, but the linker doesn't know. Hide the call from -+ // the linker analysis by using an indirect call. -+ BEQ ZERO, g, needm -+ -+ MOV g_m(g), X5 -+ MOV X5, savedm-8(SP) -+ JMP havem -+ -+needm: -+ MOV g, savedm-8(SP) // g is zero, so is m. -+ MOV $runtime·needm(SB), X6 -+ JALR RA, X6 -+ -+ // Set m->sched.sp = SP, so that if a panic happens -+ // during the function we are about to execute, it will -+ // have a valid SP to run on the g0 stack. -+ // The next few lines (after the havem label) -+ // will save this SP onto the stack and then write -+ // the same SP back to m->sched.sp. That seems redundant, -+ // but if an unrecovered panic happens, unwindm will -+ // restore the g->sched.sp from the stack location -+ // and then systemstack will try to use it. If we don't set it here, -+ // that restored SP will be uninitialized (typically 0) and -+ // will not be usable. -+ MOV g_m(g), X5 -+ MOV m_g0(X5), X6 -+ MOV X2, (g_sched+gobuf_sp)(X6) -+ -+havem: -+ // Now there's a valid m, and we're running on its m->g0. -+ // Save current m->g0->sched.sp on stack and then set it to SP. -+ // Save current sp in m->g0->sched.sp in preparation for -+ // switch back to m->curg stack. -+ // NOTE: unwindm knows that the saved g->sched.sp is at 8(R29) aka savedsp-16(SP). -+ MOV m_g0(X5), X6 -+ MOV (g_sched+gobuf_sp)(X6), X7 -+ MOV X7, savedsp-16(SP) -+ MOV X2, (g_sched+gobuf_sp)(X6) -+ -+ // Switch to m->curg stack and call runtime.cgocallbackg. -+ // Because we are taking over the execution of m->curg -+ // but *not* resuming what had been running, we need to -+ // save that information (m->curg->sched) so we can restore it. -+ // We can restore m->curg->sched.sp easily, because calling -+ // runtime.cgocallbackg leaves SP unchanged upon return. -+ // To save m->curg->sched.pc, we push it onto the stack. -+ // This has the added benefit that it looks to the traceback -+ // routine like cgocallbackg is going to return to that -+ // PC (because the frame we allocate below has the same -+ // size as cgocallback_gofunc's frame declared above) -+ // so that the traceback will seamlessly trace back into -+ // the earlier calls. -+ // -+ // In the new goroutine, -8(SP) is unused (where SP refers to -+ // m->curg's SP while we're setting it up, before we've adjusted it). -+ MOV m_curg(X5), g -+ CALL runtime·save_g(SB) -+ MOV (g_sched+gobuf_sp)(g), X6 // prepare stack as X6 -+ MOV (g_sched+gobuf_pc)(g), X7 -+ MOV X7, -24(X6) -+ MOV ctxt+24(FP), X8 -+ MOV X8, -16(X6) -+ MOV $-24(X6), X2 -+ CALL runtime·cgocallbackg(SB) -+ -+ // Restore g->sched (== m->curg->sched) from saved values. -+ MOV 0(X2), X7 -+ MOV X7, (g_sched+gobuf_pc)(g) -+ MOV $24(X2), X6 -+ MOV X6, (g_sched+gobuf_sp)(g) -+ -+ // Switch back to m->g0's stack and restore m->g0->sched.sp. -+ // (Unlike m->curg, the g0 goroutine never uses sched.pc, -+ // so we do not have to restore it.) -+ MOV g_m(g), X5 -+ MOV m_g0(X5), g -+ CALL runtime·save_g(SB) -+ MOV (g_sched+gobuf_sp)(g), X2 -+ MOV savedsp-16(SP), X6 -+ MOV X6, (g_sched+gobuf_sp)(g) -+ -+ // If the m on entry was nil, we called needm above to borrow an m -+ // for the duration of the call. Since the call is over, return it with dropm. -+ MOV savedm-8(SP), X5 -+ BNE ZERO, X5, droppedm -+ MOV $runtime·dropm(SB), X6 -+ JALR RA, X6 -+droppedm: -+ -+ // Done! -+ RET - - TEXT runtime·breakpoint(SB),NOSPLIT|NOFRAME,$0-0 - EBREAK -diff --git a/src/runtime/cgo/asm_riscv64.s b/src/runtime/cgo/asm_riscv64.s -new file mode 100644 -index 0000000..81fee7a ---- /dev/null -+++ b/src/runtime/cgo/asm_riscv64.s -@@ -0,0 +1,88 @@ -+// Copyright 2020 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. -+ -+// +build riscv64 -+ -+#include "textflag.h" -+ -+/* -+ * void crosscall2(void (*fn)(void*, int32, uintptr), void*, int32, uintptr) -+ * Save registers and call fn with two arguments. -+ */ -+TEXT crosscall2(SB),NOSPLIT|NOFRAME,$0 -+ /* -+ * Push arguments for fn (X10, X11, X12), along with all callee-save -+ * registers. Note that at procedure entry the first argument is at -+ * 8(X2). -+ */ -+ ADD $(-8*31), X2 -+ MOV X11, (8*1)(X2) // void* -+ MOVW X12, (8*2)(X2) // int32 -+ MOV X13, (8*3)(X2) // uintptr -+ MOV X8, (8*4)(X2) -+ MOV X9, (8*5)(X2) -+ MOV X18, (8*6)(X2) -+ MOV X19, (8*7)(X2) -+ MOV X20, (8*8)(X2) -+ MOV X21, (8*9)(X2) -+ MOV X22, (8*10)(X2) -+ MOV X23, (8*11)(X2) -+ MOV X24, (8*12)(X2) -+ MOV X25, (8*13)(X2) -+ MOV X26, (8*14)(X2) -+ MOV X27, (8*15)(X2) -+ MOV X3, (8*16)(X2) -+ MOV X4, (8*17)(X2) -+ MOV X1, (8*18)(X2) -+ MOVD F8, (8*19)(X2) -+ MOVD F9, (8*20)(X2) -+ MOVD F18, (8*21)(X2) -+ MOVD F19, (8*22)(X2) -+ MOVD F20, (8*23)(X2) -+ MOVD F21, (8*24)(X2) -+ MOVD F22, (8*25)(X2) -+ MOVD F23, (8*26)(X2) -+ MOVD F24, (8*27)(X2) -+ MOVD F25, (8*28)(X2) -+ MOVD F26, (8*29)(X2) -+ MOVD F27, (8*30)(X2) -+ -+ // Initialize Go ABI environment -+ // prepare SB register = PC & 0xffffffff00000000 -+ AUIPC $0, X3 -+ SRL $32, X3 -+ SLL $32, X3 -+ CALL runtime·load_g(SB) -+ JALR RA, X10 -+ -+ MOV (8*4)(X2), X8 -+ MOV (8*5)(X2), X9 -+ MOV (8*6)(X2), X18 -+ MOV (8*7)(X2), X19 -+ MOV (8*8)(X2), X20 -+ MOV (8*9)(X2), X21 -+ MOV (8*10)(X2), X22 -+ MOV (8*11)(X2), X23 -+ MOV (8*12)(X2), X24 -+ MOV (8*13)(X2), X25 -+ MOV (8*14)(X2), X26 -+ MOV (8*15)(X2), X27 -+ MOV (8*16)(X2), X3 -+ MOV (8*17)(X2), X4 -+ MOV (8*18)(X2), X1 -+ MOVD (8*19)(X2), F8 -+ MOVD (8*20)(X2), F9 -+ MOVD (8*21)(X2), F18 -+ MOVD (8*22)(X2), F19 -+ MOVD (8*23)(X2), F20 -+ MOVD (8*24)(X2), F21 -+ MOVD (8*25)(X2), F22 -+ MOVD (8*26)(X2), F23 -+ MOVD (8*27)(X2), F24 -+ MOVD (8*28)(X2), F25 -+ MOVD (8*29)(X2), F26 -+ MOVD (8*30)(X2), F27 -+ ADD $(8*31), X2 -+ -+ RET -diff --git a/src/runtime/cgo/gcc_linux_riscv64.c b/src/runtime/cgo/gcc_linux_riscv64.c -new file mode 100644 -index 0000000..f04c325 ---- /dev/null -+++ b/src/runtime/cgo/gcc_linux_riscv64.c -@@ -0,0 +1,78 @@ -+// 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. -+ -+// +build cgo -+// +build linux -+// +build riscv64 -+ -+#include -+#include -+#include -+#include "libcgo.h" -+#include "libcgo_unix.h" -+ -+static void *threadentry(void*); -+ -+void (*x_cgo_inittls)(void **tlsg, void **tlsbase); -+static void (*setg_gcc)(void*); -+ -+void -+_cgo_sys_thread_start(ThreadStart *ts) -+{ -+ pthread_attr_t attr; -+ sigset_t ign, oset; -+ pthread_t p; -+ size_t size; -+ int err; -+ -+ sigfillset(&ign); -+ pthread_sigmask(SIG_SETMASK, &ign, &oset); -+ -+ // Not sure why the memset is necessary here, -+ // but without it, we get a bogus stack size -+ // out of pthread_attr_getstacksize. C'est la Linux. -+ memset(&attr, 0, sizeof attr); -+ pthread_attr_init(&attr); -+ size = 0; -+ pthread_attr_getstacksize(&attr, &size); -+ // Leave stacklo=0 and set stackhi=size; mstart will do the rest. -+ ts->g->stackhi = size; -+ err = _cgo_try_pthread_create(&p, &attr, threadentry, ts); -+ -+ pthread_sigmask(SIG_SETMASK, &oset, nil); -+ -+ if (err != 0) { -+ fatalf("pthread_create failed: %s", strerror(err)); -+ } -+} -+ -+extern void crosscall1(void (*fn)(void), void (*setg_gcc)(void*), void *g); -+static void* -+threadentry(void *v) -+{ -+ ThreadStart ts; -+ -+ ts = *(ThreadStart*)v; -+ free(v); -+ -+ crosscall1(ts.fn, setg_gcc, (void*)ts.g); -+ return nil; -+} -+ -+void -+x_cgo_init(G *g, void (*setg)(void*), void **tlsg, void **tlsbase) -+{ -+ pthread_attr_t attr; -+ size_t size; -+ -+ setg_gcc = setg; -+ pthread_attr_init(&attr); -+ pthread_attr_getstacksize(&attr, &size); -+ g->stacklo = (uintptr)&attr - size + 4096; -+ pthread_attr_destroy(&attr); -+ -+ if (x_cgo_inittls) { -+ x_cgo_inittls(tlsg, tlsbase); -+ } -+} -diff --git a/src/runtime/cgo/gcc_riscv64.S b/src/runtime/cgo/gcc_riscv64.S -new file mode 100644 -index 0000000..05d35c8 ---- /dev/null -+++ b/src/runtime/cgo/gcc_riscv64.S -@@ -0,0 +1,87 @@ -+// Copyright 2020 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. -+ -+// +build riscv64 -+ -+/* -+ * void crosscall1(void (*fn)(void), void (*setg_gcc)(void *g), void *g) -+ * -+ * Calling into the gc tool chain, where all registers are caller save. -+ * Called from standard RISCV ELF psABI, where x8-x9, x18-x27, f8-f9 and -+ * f18-f27 are callee-save, so they must be saved explicitly, along with -+ * x1 (LR). -+ */ -+.globl crosscall1 -+crosscall1: -+ sd x1, -200(sp) -+ addi sp, sp, -200 -+ sd x8, 8(sp) -+ sd x9, 16(sp) -+ sd x18, 24(sp) -+ sd x19, 32(sp) -+ sd x20, 40(sp) -+ sd x21, 48(sp) -+ sd x22, 56(sp) -+ sd x23, 64(sp) -+ sd x24, 72(sp) -+ sd x25, 80(sp) -+ sd x26, 88(sp) -+ sd x27, 96(sp) -+ fsd f8, 104(sp) -+ fsd f9, 112(sp) -+ fsd f18, 120(sp) -+ fsd f19, 128(sp) -+ fsd f20, 136(sp) -+ fsd f21, 144(sp) -+ fsd f22, 152(sp) -+ fsd f23, 160(sp) -+ fsd f24, 168(sp) -+ fsd f25, 176(sp) -+ fsd f26, 184(sp) -+ fsd f27, 192(sp) -+ -+ // prepare SB register = pc & 0xffffffff00000000 -+ auipc x3, 0 -+ srli x3, x3, 32 -+ slli x3, x3, 32 -+ -+ // a0 = *fn, a1 = *setg_gcc, a2 = *g -+ mv s1, a0 -+ mv s0, a1 -+ mv a0, a2 -+ jalr ra, s0 // call setg_gcc (clobbers x30 aka g) -+ jalr ra, s1 // call fn -+ -+ ld x1, 0(sp) -+ ld x8, 8(sp) -+ ld x9, 16(sp) -+ ld x18, 24(sp) -+ ld x19, 32(sp) -+ ld x20, 40(sp) -+ ld x21, 48(sp) -+ ld x22, 56(sp) -+ ld x23, 64(sp) -+ ld x24, 72(sp) -+ ld x25, 80(sp) -+ ld x26, 88(sp) -+ ld x27, 96(sp) -+ fld f8, 104(sp) -+ fld f9, 112(sp) -+ fld f18, 120(sp) -+ fld f19, 128(sp) -+ fld f20, 136(sp) -+ fld f21, 144(sp) -+ fld f22, 152(sp) -+ fld f23, 160(sp) -+ fld f24, 168(sp) -+ fld f25, 176(sp) -+ fld f26, 184(sp) -+ fld f27, 192(sp) -+ addi sp, sp, 200 -+ -+ jr ra -+ -+#ifdef __ELF__ -+.section .note.GNU-stack,"",%progbits -+#endif -diff --git a/src/runtime/cgocall.go b/src/runtime/cgocall.go -index a4e64b0..a0ae037 100644 ---- a/src/runtime/cgocall.go -+++ b/src/runtime/cgocall.go -@@ -321,6 +321,10 @@ func cgocallbackg1(ctxt uintptr) { - // On mipsx, stack frame is two words and there's a saved LR between - // SP and the stack frame and between the stack frame and the arguments. - cb = (*args)(unsafe.Pointer(sp + 4*sys.PtrSize)) -+ case "riscv64": -+ // On riscv64, stack frame is two words and there's a saved LR between -+ // SP and the stack frame and between the stack frame and the arguments. -+ cb = (*args)(unsafe.Pointer(sp + 4*sys.PtrSize)) - } - - // Invoke callback. -@@ -356,7 +360,7 @@ func unwindm(restore *bool) { - switch GOARCH { - default: - throw("unwindm not implemented") -- case "386", "amd64", "arm", "ppc64", "ppc64le", "mips64", "mips64le", "s390x", "mips", "mipsle": -+ case "386", "amd64", "arm", "ppc64", "ppc64le", "mips64", "mips64le", "s390x", "mips", "mipsle", "riscv64": - sched.sp = *(*uintptr)(unsafe.Pointer(sched.sp + sys.MinFrameSize)) - case "arm64": - sched.sp = *(*uintptr)(unsafe.Pointer(sched.sp + 16)) -diff --git a/src/runtime/sys_linux_riscv64.s b/src/runtime/sys_linux_riscv64.s -index 626ab39..3ba5a28 100644 ---- a/src/runtime/sys_linux_riscv64.s -+++ b/src/runtime/sys_linux_riscv64.s -@@ -282,6 +282,11 @@ TEXT runtime·sigfwd(SB),NOSPLIT,$0-32 - - // func sigtramp(signo, ureg, ctxt unsafe.Pointer) - TEXT runtime·sigtramp(SB),NOSPLIT,$64 -+ // initialize SB = PC&0xffffffff00000000 -+ AUIPC $0, X3 -+ SRL $32, X3 -+ SLL $32, X3 -+ - MOVW A0, 8(X2) - MOV A1, 16(X2) - MOV A2, 24(X2) -diff --git a/src/runtime/tls_riscv64.s b/src/runtime/tls_riscv64.s -index 8386980..020888d 100644 ---- a/src/runtime/tls_riscv64.s -+++ b/src/runtime/tls_riscv64.s -@@ -9,10 +9,22 @@ - - // If !iscgo, this is a no-op. - // --// NOTE: mcall() assumes this clobbers only R23 (REGTMP). --// FIXME: cgo -+// NOTE: mcall() assumes this clobbers only X31 (REG_TMP). - TEXT runtime·save_g(SB),NOSPLIT|NOFRAME,$0-0 -+ MOVB runtime·iscgo(SB), X31 -+ BEQ X0, X31, nocgo -+ -+ MOV runtime·tls_g(SB), X31 -+ ADD X4, X31 -+ MOV g, (X31) -+ -+nocgo: - RET - - TEXT runtime·load_g(SB),NOSPLIT|NOFRAME,$0-0 -+ MOV runtime·tls_g(SB), X31 -+ ADD X4, X31 -+ MOV (X31), g - RET -+ -+GLOBL runtime·tls_g(SB), TLSBSS, $8 --- -1.8.3.1 - diff --git a/riscv-support-external-linking.patch b/riscv-support-external-linking.patch deleted file mode 100644 index 6d84b7f210df90400ac7ca27c8f379174abcdef3..0000000000000000000000000000000000000000 --- a/riscv-support-external-linking.patch +++ /dev/null @@ -1,476 +0,0 @@ -From fc3e6af10297b424175b44d2274de04c5f0b9e82 Mon Sep 17 00:00:00 2001 -From: Joel Sing -Date: Tue, 19 May 2020 18:54:48 +1000 -Subject: [PATCH] cmd/link: add support for external linking on linux/riscv64 - -Change-Id: I9902c36c94478f2b2e0739bb68ceccc23b53f0ec ---- - src/cmd/link/internal/arm/asm.go | 2 +- - src/cmd/link/internal/arm64/asm.go | 2 +- - src/cmd/link/internal/ld/config.go | 4 +- - src/cmd/link/internal/ld/elf.go | 3 + - src/cmd/link/internal/ld/elf2.go | 2 +- - src/cmd/link/internal/ld/lib.go | 2 +- - src/cmd/link/internal/ld/pcln.go | 2 +- - src/cmd/link/internal/ld/symtab.go | 12 ++- - src/cmd/link/internal/loadelf/ldelf.go | 48 ++++++++++-- - src/cmd/link/internal/mips/asm.go | 2 +- - src/cmd/link/internal/mips64/asm.go | 2 +- - src/cmd/link/internal/ppc64/asm.go | 2 +- - src/cmd/link/internal/riscv64/asm.go | 129 ++++++++++++++++++++++++++++++++- - src/cmd/link/internal/s390x/asm.go | 2 +- - src/cmd/link/internal/x86/asm.go | 2 +- - 15 files changed, 190 insertions(+), 26 deletions(-) - -diff --git a/src/cmd/link/internal/arm/asm.go b/src/cmd/link/internal/arm/asm.go -index 903e621..7e97c13 100644 ---- a/src/cmd/link/internal/arm/asm.go -+++ b/src/cmd/link/internal/arm/asm.go -@@ -249,7 +249,7 @@ func adddynrel2(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s load - return false - } - --func elfreloc1(ctxt *ld.Link, r *sym.Reloc, sectoff int64) bool { -+func elfreloc1(ctxt *ld.Link, s *sym.Symbol, r *sym.Reloc, sectoff int64) bool { - ctxt.Out.Write32(uint32(sectoff)) - - elfsym := ld.ElfSymForReloc(ctxt, r.Xsym) -diff --git a/src/cmd/link/internal/arm64/asm.go b/src/cmd/link/internal/arm64/asm.go -index 417e4b1..aac8bec 100644 ---- a/src/cmd/link/internal/arm64/asm.go -+++ b/src/cmd/link/internal/arm64/asm.go -@@ -325,7 +325,7 @@ func adddynrel2(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s load - return false - } - --func elfreloc1(ctxt *ld.Link, r *sym.Reloc, sectoff int64) bool { -+func elfreloc1(ctxt *ld.Link, s *sym.Symbol, r *sym.Reloc, sectoff int64) bool { - ctxt.Out.Write64(uint64(sectoff)) - - elfsym := ld.ElfSymForReloc(ctxt, r.Xsym) -diff --git a/src/cmd/link/internal/ld/config.go b/src/cmd/link/internal/ld/config.go -index 2373b50..2186bf5 100644 ---- a/src/cmd/link/internal/ld/config.go -+++ b/src/cmd/link/internal/ld/config.go -@@ -186,7 +186,7 @@ func mustLinkExternal(ctxt *Link) (res bool, reason string) { - // Internally linking cgo is incomplete on some architectures. - // https://golang.org/issue/14449 - // https://golang.org/issue/21961 -- if iscgo && ctxt.Arch.InFamily(sys.MIPS64, sys.MIPS, sys.PPC64) { -+ if iscgo && ctxt.Arch.InFamily(sys.MIPS64, sys.MIPS, sys.PPC64, sys.RISCV64) { - return true, objabi.GOARCH + " does not support internal cgo" - } - if iscgo && objabi.GOOS == "android" { -@@ -263,8 +263,6 @@ func determineLinkMode(ctxt *Link) { - } - case LinkExternal: - switch { -- case objabi.GOARCH == "riscv64": -- Exitf("external linking not supported for %s/riscv64", objabi.GOOS) - case objabi.GOARCH == "ppc64" && objabi.GOOS != "aix": - Exitf("external linking not supported for %s/ppc64", objabi.GOOS) - } -diff --git a/src/cmd/link/internal/ld/elf.go b/src/cmd/link/internal/ld/elf.go -index 78298be..5468fb8 100644 ---- a/src/cmd/link/internal/ld/elf.go -+++ b/src/cmd/link/internal/ld/elf.go -@@ -506,6 +506,9 @@ func Elfinit(ctxt *Link) { - if ctxt.Arch.Family == sys.MIPS64 { - ehdr.flags = 0x20000004 /* MIPS 3 CPIC */ - } -+ if ctxt.Arch.Family == sys.RISCV64 { -+ ehdr.flags = 0x4 /* RISCV Float ABI Double */ -+ } - elf64 = true - - ehdr.phoff = ELF64HDRSIZE /* Must be ELF64HDRSIZE: first PHdr must follow ELF header */ -diff --git a/src/cmd/link/internal/ld/elf2.go b/src/cmd/link/internal/ld/elf2.go -index 07b64cf..41c927c 100644 ---- a/src/cmd/link/internal/ld/elf2.go -+++ b/src/cmd/link/internal/ld/elf2.go -@@ -69,7 +69,7 @@ func elfrelocsect2(ctxt *Link, sect *sym.Section, syms []*sym.Symbol) { - if !r.Xsym.Attr.Reachable() { - Errorf(s, "unreachable reloc %d (%s) target %v", r.Type, sym.RelocName(ctxt.Arch, r.Type), r.Xsym.Name) - } -- if !thearch.Elfreloc1(ctxt, r, int64(uint64(s.Value+int64(r.Off))-sect.Vaddr)) { -+ if !thearch.Elfreloc1(ctxt, s, r, int64(uint64(s.Value+int64(r.Off))-sect.Vaddr)) { - Errorf(s, "unsupported obj reloc %d (%s)/%d to %s", r.Type, sym.RelocName(ctxt.Arch, r.Type), r.Siz, r.Sym.Name) - } - } -diff --git a/src/cmd/link/internal/ld/lib.go b/src/cmd/link/internal/ld/lib.go -index 0366bc7..873c1e8 100644 ---- a/src/cmd/link/internal/ld/lib.go -+++ b/src/cmd/link/internal/ld/lib.go -@@ -271,7 +271,7 @@ type Arch struct { - Asmb func(*Link, *loader.Loader) - Asmb2 func(*Link) - -- Elfreloc1 func(*Link, *sym.Reloc, int64) bool -+ Elfreloc1 func(*Link, *sym.Symbol, *sym.Reloc, int64) bool - Elfreloc2 func(*Link, *loader.Loader, loader.Sym, loader.ExtRelocView, int64) bool - Elfsetupplt func(ctxt *Link, plt, gotplt *loader.SymbolBuilder, dynamic loader.Sym) - Gentext func(*Link) -diff --git a/src/cmd/link/internal/ld/pcln.go b/src/cmd/link/internal/ld/pcln.go -index 5cbb7bb..ac97871 100644 ---- a/src/cmd/link/internal/ld/pcln.go -+++ b/src/cmd/link/internal/ld/pcln.go -@@ -574,7 +574,7 @@ func expandGoroot(s string) string { - - const ( - BUCKETSIZE = 256 * MINFUNC -- SUBBUCKETS = 16 -+ SUBBUCKETS = 32 - SUBBUCKETSIZE = BUCKETSIZE / SUBBUCKETS - NOIDX = 0x7fffffff - ) -diff --git a/src/cmd/link/internal/ld/symtab.go b/src/cmd/link/internal/ld/symtab.go -index 46aa33b..28a728f 100644 ---- a/src/cmd/link/internal/ld/symtab.go -+++ b/src/cmd/link/internal/ld/symtab.go -@@ -185,7 +185,11 @@ func putelfsym(ctxt *Link, x *sym.Symbol, s string, t SymbolType, addr int64) { - // ELF linker -Bsymbolic-functions option, but that is buggy on - // several platforms. - putelfsyment(ctxt.Out, putelfstr("local."+s), addr, size, STB_LOCAL<<4|typ&0xf, elfshnum, other) -- ctxt.loader.SetSymLocalElfSym(loader.Sym(x.SymIdx), int32(ctxt.numelfsym)) -+ if ctxt.Target.IsRISCV64() && x.SymIdx == 0 { -+ x.SetGot(int32(ctxt.numelfsym)) -+ } else { -+ ctxt.loader.SetSymLocalElfSym(loader.Sym(x.SymIdx), int32(ctxt.numelfsym)) -+ } - ctxt.numelfsym++ - return - } else if bind != ctxt.elfbind { -@@ -193,7 +197,11 @@ func putelfsym(ctxt *Link, x *sym.Symbol, s string, t SymbolType, addr int64) { - } - - putelfsyment(ctxt.Out, putelfstr(s), addr, size, bind<<4|typ&0xf, elfshnum, other) -- ctxt.loader.SetSymElfSym(loader.Sym(x.SymIdx), int32(ctxt.numelfsym)) -+ if ctxt.Target.IsRISCV64() && x.SymIdx == 0 { -+ x.SetGot(int32(ctxt.numelfsym)) -+ } else { -+ ctxt.loader.SetSymElfSym(loader.Sym(x.SymIdx), int32(ctxt.numelfsym)) -+ } - ctxt.numelfsym++ - } - -diff --git a/src/cmd/link/internal/loadelf/ldelf.go b/src/cmd/link/internal/loadelf/ldelf.go -index bb5b4ff..1f5fd64 100644 ---- a/src/cmd/link/internal/loadelf/ldelf.go -+++ b/src/cmd/link/internal/loadelf/ldelf.go -@@ -372,6 +372,11 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, f *bio.Reader, - return errorf("elf object but not ppc64") - } - -+ case sys.RISCV64: -+ if mach != elf.EM_RISCV || class != elf.ELFCLASS64 { -+ return errorf("elf object but not riscv64") -+ } -+ - case sys.S390X: - if mach != elf.EM_S390 || class != elf.ELFCLASS64 { - return errorf("elf object but not s390x") -@@ -591,6 +596,11 @@ func Load(l *loader.Loader, arch *sys.Arch, localSymVersion int, f *bio.Reader, - continue - } - -+ if strings.HasPrefix(sect.name, ".debug_") && elfsym.type_ == 0 { -+ // This happens with gcc on RISCV64. -+ continue -+ } -+ - if strings.HasPrefix(elfsym.name, ".LASF") { // gcc on s390x does this - continue - } -@@ -946,14 +956,15 @@ func relSize(arch *sys.Arch, pn string, elftype uint32) (uint8, error) { - // performance. - - const ( -- AMD64 = uint32(sys.AMD64) -- ARM = uint32(sys.ARM) -- ARM64 = uint32(sys.ARM64) -- I386 = uint32(sys.I386) -- PPC64 = uint32(sys.PPC64) -- S390X = uint32(sys.S390X) -- MIPS = uint32(sys.MIPS) -- MIPS64 = uint32(sys.MIPS64) -+ AMD64 = uint32(sys.AMD64) -+ ARM = uint32(sys.ARM) -+ ARM64 = uint32(sys.ARM64) -+ I386 = uint32(sys.I386) -+ MIPS = uint32(sys.MIPS) -+ MIPS64 = uint32(sys.MIPS64) -+ PPC64 = uint32(sys.PPC64) -+ RISCV64 = uint32(sys.RISCV64) -+ S390X = uint32(sys.S390X) - ) - - switch uint32(arch.Family) | elftype<<16 { -@@ -1056,6 +1067,27 @@ func relSize(arch *sys.Arch, pn string, elftype uint32) (uint8, error) { - S390X | uint32(elf.R_390_GOT64)<<16, - S390X | uint32(elf.R_390_PLT64)<<16: - return 8, nil -+ -+ case RISCV64 | uint32(elf.R_RISCV_RVC_BRANCH)<<16, -+ RISCV64 | uint32(elf.R_RISCV_RVC_JUMP)<<16: -+ return 2, nil -+ -+ case RISCV64 | uint32(elf.R_RISCV_32)<<16, -+ RISCV64 | uint32(elf.R_RISCV_BRANCH)<<16, -+ RISCV64 | uint32(elf.R_RISCV_HI20)<<16, -+ RISCV64 | uint32(elf.R_RISCV_LO12_I)<<16, -+ RISCV64 | uint32(elf.R_RISCV_LO12_S)<<16, -+ RISCV64 | uint32(elf.R_RISCV_GOT_HI20)<<16, -+ RISCV64 | uint32(elf.R_RISCV_PCREL_HI20)<<16, -+ RISCV64 | uint32(elf.R_RISCV_PCREL_LO12_I)<<16, -+ RISCV64 | uint32(elf.R_RISCV_PCREL_LO12_S)<<16, -+ RISCV64 | uint32(elf.R_RISCV_RELAX)<<16: -+ return 4, nil -+ -+ case RISCV64 | uint32(elf.R_RISCV_64)<<16, -+ RISCV64 | uint32(elf.R_RISCV_CALL)<<16, -+ RISCV64 | uint32(elf.R_RISCV_CALL_PLT)<<16: -+ return 8, nil - } - } - -diff --git a/src/cmd/link/internal/mips/asm.go b/src/cmd/link/internal/mips/asm.go -index 9710b9c..37a7700 100644 ---- a/src/cmd/link/internal/mips/asm.go -+++ b/src/cmd/link/internal/mips/asm.go -@@ -51,7 +51,7 @@ func adddynrel(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s *sym. - return false - } - --func elfreloc1(ctxt *ld.Link, r *sym.Reloc, sectoff int64) bool { -+func elfreloc1(ctxt *ld.Link, s *sym.Symbol, r *sym.Reloc, sectoff int64) bool { - ctxt.Out.Write32(uint32(sectoff)) - - elfsym := ld.ElfSymForReloc(ctxt, r.Xsym) -diff --git a/src/cmd/link/internal/mips64/asm.go b/src/cmd/link/internal/mips64/asm.go -index b48241b..b688a8f 100644 ---- a/src/cmd/link/internal/mips64/asm.go -+++ b/src/cmd/link/internal/mips64/asm.go -@@ -49,7 +49,7 @@ func adddynrel(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s *sym. - return false - } - --func elfreloc1(ctxt *ld.Link, r *sym.Reloc, sectoff int64) bool { -+func elfreloc1(ctxt *ld.Link, s *sym.Symbol, r *sym.Reloc, sectoff int64) bool { - // mips64 ELF relocation (endian neutral) - // offset uint64 - // sym uint32 -diff --git a/src/cmd/link/internal/ppc64/asm.go b/src/cmd/link/internal/ppc64/asm.go -index b1c0873..1aa5051 100644 ---- a/src/cmd/link/internal/ppc64/asm.go -+++ b/src/cmd/link/internal/ppc64/asm.go -@@ -443,7 +443,7 @@ func xcoffreloc1(arch *sys.Arch, out *ld.OutBuf, s *sym.Symbol, r *sym.Reloc, se - - } - --func elfreloc1(ctxt *ld.Link, r *sym.Reloc, sectoff int64) bool { -+func elfreloc1(ctxt *ld.Link, s *sym.Symbol, r *sym.Reloc, sectoff int64) bool { - // Beware that bit0~bit15 start from the third byte of a instruction in Big-Endian machines. - if r.Type == objabi.R_ADDR || r.Type == objabi.R_POWER_TLS || r.Type == objabi.R_CALLPOWER { - } else { -diff --git a/src/cmd/link/internal/riscv64/asm.go b/src/cmd/link/internal/riscv64/asm.go -index 5183de8..a3f19b2 100644 ---- a/src/cmd/link/internal/riscv64/asm.go -+++ b/src/cmd/link/internal/riscv64/asm.go -@@ -11,11 +11,16 @@ import ( - "cmd/link/internal/ld" - "cmd/link/internal/loader" - "cmd/link/internal/sym" -+ "debug/elf" - "fmt" - "log" -+ "sort" - "sync" - ) - -+// fakeLabelName matches the RISCV_FAKE_LABEL_NAME from binutils. -+const fakeLabelName = ".L0 " -+ - func gentext2(ctxt *ld.Link, ldr *loader.Loader) { - } - -@@ -28,9 +33,72 @@ func adddynrel(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s *sym. - return false - } - --func elfreloc1(ctxt *ld.Link, r *sym.Reloc, sectoff int64) bool { -- log.Fatalf("elfreloc1") -- return false -+func findHI20Symbol(ctxt *ld.Link, val int64) *sym.Symbol { -+ for idx := sort.Search(len(ctxt.Textp), func(i int) bool { return ctxt.Textp[i].Value >= val }); idx < len(ctxt.Textp); idx++ { -+ s := ctxt.Textp[idx] -+ if s.Value != val { -+ return nil -+ } -+ if s.Type == sym.STEXT && s.Name == fakeLabelName { -+ return s -+ } -+ } -+ return nil -+} -+ -+func elfreloc1(ctxt *ld.Link, s *sym.Symbol, r *sym.Reloc, sectoff int64) bool { -+ elfsym := ld.ElfSymForReloc(ctxt, r.Xsym) -+ switch r.Type { -+ case objabi.R_ADDR: -+ ctxt.Out.Write64(uint64(sectoff)) -+ switch r.Siz { -+ case 4: -+ ctxt.Out.Write64(uint64(elf.R_RISCV_32) | uint64(elfsym)<<32) -+ case 8: -+ ctxt.Out.Write64(uint64(elf.R_RISCV_64) | uint64(elfsym)<<32) -+ default: -+ ld.Errorf(nil, "unknown size %d for %v relocation", r.Siz, r.Type) -+ return false -+ } -+ ctxt.Out.Write64(uint64(r.Xadd)) -+ -+ case objabi.R_CALLRISCV: -+ // Call relocations are currently handled via R_RISCV_PCREL_ITYPE. -+ // TODO(jsing): Consider generating elf.R_RISCV_CALL instead of a -+ // HI20/LO12_I pair. -+ -+ case objabi.R_RISCV_PCREL_ITYPE, objabi.R_RISCV_PCREL_STYPE: -+ // Find the text symbol for the AUIPC instruction targeted -+ // by this relocation. -+ hi20Sym := findHI20Symbol(ctxt, s.Value+int64(r.Off)) -+ if hi20Sym == nil || hi20Sym.Type != sym.STEXT { -+ ld.Errorf(nil, "failed to find text symbol for HI20 relocation at %d (%x)", sectoff, s.Value+int64(r.Off)) -+ return false -+ } -+ -+ // Emit two relocations - a R_RISCV_PCREL_HI20 relocation and a -+ // corresponding R_RISCV_PCREL_LO12_I or R_RISCV_PCREL_LO12_S relocation. -+ // Note that the LO12 relocation must refer to a text symbol that points -+ // to the instruction that has the HI20 relocation given for a symbol. -+ var hiRel, loRel elf.R_RISCV -+ switch r.Type { -+ case objabi.R_RISCV_PCREL_ITYPE: -+ hiRel, loRel = elf.R_RISCV_PCREL_HI20, elf.R_RISCV_PCREL_LO12_I -+ case objabi.R_RISCV_PCREL_STYPE: -+ hiRel, loRel = elf.R_RISCV_PCREL_HI20, elf.R_RISCV_PCREL_LO12_S -+ } -+ ctxt.Out.Write64(uint64(sectoff)) -+ ctxt.Out.Write64(uint64(hiRel) | uint64(elfsym)<<32) -+ ctxt.Out.Write64(uint64(r.Xadd)) -+ ctxt.Out.Write64(uint64(sectoff + 4)) -+ ctxt.Out.Write64(uint64(loRel) | uint64(hi20Sym.Got())<<32) -+ ctxt.Out.Write64(uint64(0)) -+ -+ default: -+ return false -+ } -+ -+ return true - } - - func elfsetupplt(ctxt *ld.Link, plt, gotplt *loader.SymbolBuilder, dynamic loader.Sym) { -@@ -43,6 +111,36 @@ func machoreloc1(arch *sys.Arch, out *ld.OutBuf, s *sym.Symbol, r *sym.Reloc, se - } - - func archreloc(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym.Symbol, val int64) (int64, bool) { -+ if target.IsExternal() { -+ switch r.Type { -+ case objabi.R_CALLRISCV: -+ r.Done = false -+ r.Xsym = r.Sym -+ r.Xadd = r.Add -+ return val, true -+ -+ case objabi.R_RISCV_PCREL_ITYPE, objabi.R_RISCV_PCREL_STYPE: -+ r.Done = false -+ -+ // Set up addend for eventual relocation via outer symbol. -+ rs := r.Sym -+ r.Xadd = r.Add -+ for rs.Outer != nil { -+ r.Xadd += ld.Symaddr(rs) - ld.Symaddr(rs.Outer) -+ rs = rs.Outer -+ } -+ -+ if rs.Type != sym.SHOSTOBJ && rs.Type != sym.SDYNIMPORT && rs.Sect == nil { -+ ld.Errorf(s, "missing section for %s", rs.Name) -+ } -+ r.Xsym = rs -+ -+ return val, true -+ } -+ -+ return val, false -+ } -+ - switch r.Type { - case objabi.R_CALLRISCV: - // Nothing to do. -@@ -98,6 +196,29 @@ func archrelocvariant(target *ld.Target, syms *ld.ArchSyms, r *sym.Reloc, s *sym - return -1 - } - -+func genHi20TextSymbols(ctxt *ld.Link) { -+ // Generate a local text symbol for each relocation target, as the -+ // R_RISCV_PCREL_LO12_* relocations generated by elfreloc1 need it. -+ var syms []*sym.Symbol -+ for _, s := range ctxt.Textp { -+ for _, r := range s.R { -+ if r.Type != objabi.R_RISCV_PCREL_ITYPE && r.Type != objabi.R_RISCV_PCREL_STYPE { -+ continue -+ } -+ sym := &sym.Symbol{ -+ Type: sym.STEXT, -+ Name: fakeLabelName, -+ Value: s.Value + int64(r.Off), -+ Attr: sym.AttrDuplicateOK | sym.AttrLocal | sym.AttrVisibilityHidden, -+ Sect: s.Sect, -+ } -+ syms = append(syms, sym) -+ } -+ } -+ ctxt.Textp = append(ctxt.Textp, syms...) -+ sort.SliceStable(ctxt.Textp, func(i, j int) bool { return ctxt.Textp[i].Value < ctxt.Textp[j].Value }) -+} -+ - func asmb(ctxt *ld.Link, _ *loader.Loader) { - if ctxt.IsELF { - ld.Asmbelfsetup() -@@ -141,6 +262,8 @@ func asmb2(ctxt *ld.Link) { - symo = uint32(ld.Rnd(int64(symo), int64(*ld.FlagRound))) - ctxt.Out.SeekSet(int64(symo)) - -+ genHi20TextSymbols(ctxt) -+ - ld.Asmelfsym(ctxt) - ctxt.Out.Write(ld.Elfstrdat) - -diff --git a/src/cmd/link/internal/s390x/asm.go b/src/cmd/link/internal/s390x/asm.go -index 2115b5f..0069259 100644 ---- a/src/cmd/link/internal/s390x/asm.go -+++ b/src/cmd/link/internal/s390x/asm.go -@@ -221,7 +221,7 @@ func adddynrel2(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s load - return false - } - --func elfreloc1(ctxt *ld.Link, r *sym.Reloc, sectoff int64) bool { -+func elfreloc1(ctxt *ld.Link, s *sym.Symbol, r *sym.Reloc, sectoff int64) bool { - ctxt.Out.Write64(uint64(sectoff)) - - elfsym := ld.ElfSymForReloc(ctxt, r.Xsym) -diff --git a/src/cmd/link/internal/x86/asm.go b/src/cmd/link/internal/x86/asm.go -index b218ffa..4713f1c 100644 ---- a/src/cmd/link/internal/x86/asm.go -+++ b/src/cmd/link/internal/x86/asm.go -@@ -340,7 +340,7 @@ func adddynrel2(target *ld.Target, ldr *loader.Loader, syms *ld.ArchSyms, s load - return false - } - --func elfreloc1(ctxt *ld.Link, r *sym.Reloc, sectoff int64) bool { -+func elfreloc1(ctxt *ld.Link, s *sym.Symbol, r *sym.Reloc, sectoff int64) bool { - ctxt.Out.Write32(uint32(sectoff)) - - elfsym := ld.ElfSymForReloc(ctxt, r.Xsym) --- -1.8.3.1 -