700ICSu)tU:6K)[Ѫ#JɊ]]uOk(mTFڷuk"}, $H&<`f`9(!d1b񪴡t # NDFILE = 40 SYS_SOCKET = 41 SYS_CONNECT = 42 SYS_ACCEPT = 43 SYS_SENDTO = 44 SYS_RECVFROM = 45 SYS_SENDMSG = 46 SYS_RECVMSG = 47 SYS_SHUTDOWN = 48 SYS_BIND = 49 SYS_LISTEN = 50 SYS_GETSOCKNAME = 51 SYS_GETPEERNAME tString removes type parameter debugging markers from an object // string, to normalize it for comparison. // TODO(rfindley): this should not be necessary. func sanitizeObjectString(s string) string { var runes []rune for _, r := range s { if '₀' <= r && r < '₀'+10 { continue // trim type parameter subscripts } runes = append(runes, r) } return string(runes) } func checkFile(t *testing.T, filename string, src []byte) *types.Package { fset := token.NewFileSet() f, err := parser.ParseFile(fset, filename, src, 0) 6; func _()(x int) { return }`, `x`, ``}, {`package m6; type T int; func (x T) _() {}`, `x`, ``}, } for _, test := range tests { info := Info{Types: make(map[ast.Expr]TypeAndValue)} name := mustTypecheck(test.src, nil, &info).Name() // look for expression predicates got := "" for e, tv := range info.Types { //println(name, ExprString(e)) if ExprString(e) == test.expr { got = predString(tv) break } } if got != test.pred { t.Errorf("package %s: got %s; want %s", namefmt" "go/ast" . "internal/types/errors" "strings" ) // assignment reports whether x can be assigned to a variable of type T, // if necessary by attempting to convert untyped values to the appropriate // type. context describes the context in which the assignment takes place. // Use T == nil to indicate assignment to an untyped blank identifier. // If the assignment check fails, x.mode is set to invalid. func (check *Checker) assignment(x *operand, T Type, context string) { check.singleValue(x) switch x.mode { case invalid: in statement context } case *ast.BinaryExpr: check.binary(x, e, e.X, e.Y, e.Op, e.OpPos) if x.mode == invalid { goto Error } case *ast.KeyValueExpr: // key:value expressions are handled in composite literals check.error(e, InvalidSyntaxTree, "no key:value expected") goto Error case *ast.ArrayType, *ast.StructType, *ast.FuncType, *ast.InterfaceType, *ast.MapType, *ast.ChanType: x.mode = typexpr x.typ = check.typ(e) // Note: rawExpr (caller of exprInternal) will call check.recordTypeAndValue // even t case token.VAR: if p.tok != token.ASSIGN { typ = p.parseType() } if p.tok == token.ASSIGN { p.next() values = p.parseList(true) } default: panic("unreachable") } comment := p.expectSemi() spec := &ast.ValueSpec{ Doc: doc, Names: idents, Type: typ, Values: values, Comment: comment, } return spec } func (p *parser) parseGenericType(spec *ast.TypeSpec, openPos token.Pos, name0 *ast.Ident, typ0 ast.Expr) { if p.trace { defer un(trace(p, "parseGenericType")) } list := p.parseParameteary with single-element import paths, such as math, // which would otherwise be impossible to name. // // Note that the go/doc package provides a more sophisticated // lookup based on the imports used in the current package. func DefaultLookupPackage(name string) (importPath string, ok bool) { if isStdPkg(name) { return name, true } return "", false } // Parse parses the doc comment text and returns the *[Doc] form. // Comment markers (/* // and */) in the text must have already been removed. func (p *Parser) Parse(text strin) println() } func dumpPtrBitMap(b abi.IntArgRegBitmap) { for i := 0; i < intArgRegs; i++ { x := 0 if b.Get(i) { x = 1 } print(" ", x) } } func newAbiDesc(t *funcType, rcvr *abi.Type) abiDesc { // We need to add space for this argument to // the frame so that it can spill args into it. // // The size of this space is just the sum of the sizes // of each register-allocated type. // // TODO(mknyszek): Remove this when we no longer have // caller reserved spill space. spill := uintptr(0) // Compute gc prograeturn w.write(pr, s) } // write generates and writes a syslog formatted string. The // format is as follows: TIMESTAMP HOSTNAME TAG[PID]: MSG func (w *Writer) write(p Priority, msg string) (int, error) { // ensure it ends in a \n nl := "" if !strings.HasSuffix(msg, "\n") { nl = "\n" } err := w.conn.writeString(p, w.hostname, w.tag, msg, nl) if err != nil { return 0, err } // Note: return the length of the input, not the number of // bytes printed by Fprintf, because this must behave like // an io.Writer. retur most cases, such as the given example, this error can be resolved by // simply removing the predefined escaper from the pipeline and letting the // contextual autoescaper handle the escaping of the pipeline. In other // instances, where the predefined escaper occurs in the middle of a // pipeline where subsequent commands expect escaped input, e.g. // {{.X | html | makeALink}} // where makeALink does // return `link` // consider refactoring the surrounding template to make use oft8, int16, int64, uint, uint16, uint32, uint64, bool: fmt.Fprintf(b, "%T(%v)\n", t, t) case float32: if math.IsNaN(float64(t)) && math.Float32bits(t) != math.Float32bits(float32(math.NaN())) { // We encode unusual NaNs as hex values, because that is how users are // likely to encounter them in literature about floating-point encoding. // This allows us to reproduce fuzz failures that depend on the specific // NaN representation (for float32 there are about 2^24 possibilities!), // not just the fact that , V8, V1 // Shift by start byte VSPLTISB $0, V25 // Clear for later use index2to16next: VAND V1, SEPMASK, V2 // Just compare size of sep VCMPEQUBCC V0, V2, V3 // Compare sep and partial string BLT CR6, found // Found ADD $1, R7 // Not found, try next partial string CMP R7, LASTSTR // Check for end of string BGT notfound // If at end, then not found VSLDOI $1, V1, V25, V1 // Shift string left by 1 byte BR index2to16next // Check the ned using go/parser. InvalidMethodTypeParams // MisplacedTypeParam occurs when a type parameter is used in a place where // it is not permitted. // // Example: // type T[P any] P // // Example: // type T[P any] struct{ *P } MisplacedTypeParam // InvalidUnsafeSliceData occurs when unsafe.SliceData is called with // an argument that is not of slice type. It also occurs if it is used // in a package compiled for a language version before go1.20. // // Example: // import "unsafe" // // var x int // var _ = unsa T { return x } func _[_ any](x int) int { panic(0) } func _[T any](T /* ERROR "redeclared" */ T)() {} func _[T, T /* ERROR "redeclared" */ any]() {} // Constraints (incl. any) may be parenthesized. func _[_ (any)]() {} func _[_ (interface{})]() {} func reverse[T any](list []T) []T { rlist := make([]T, len(list)) i := len(list) for _, x := range list { i-- rlist[i] = x } return rlist } var _ = reverse /* ERROR "cannot use generic function reverse" */ var _ key is stored or deleted concurrently (including by yield), the iterator // may reflect any mapping for that key from any point during iteration. The iterator // does not block other methods on the receiver; even yield itself may call any // method on the HashTrieMap. func (ht *HashTrieMap[K, V]) All() func(yield func(K, V) bool) { ht.init() return func(yield func(key K, value V) bool) { ht.iter(ht.root.Load(), yield) } } // Range calls f sequentially for each key and value present in the map. // If f returns false, range st unsafe.Pointer) TEXT ·StorepNoWB(SB), NOSPLIT, $0 MOVD ptr+0(FP), R2 MOVD val+8(FP), R3 MOVD R3, 0(R2) SYNC RET // func Cas(ptr *uint32, old, new uint32) bool // Atomically: // if *ptr == old { // *val = new // return 1 // } else { // return 0 // } TEXT ·Cas(SB), NOSPLIT, $0-17 MOVD ptr+0(FP), R3 MOVWZ old+8(FP), R4 MOVWZ new+12(FP), R5 CS R4, R5, 0(R3) // if (R4 == 0(R3)) then 0(R3)= R5 BNE cas_fail MOVB $1, ret+16(FP) RET cas_fail: MOVB $0, ret+16(FP) RET // func Cas64(ptr *uint64, old, new uint64) bool try // For checksum computation. checksum xxhash64 } // NewReader creates a new Reader that decompresses data from the given reader. func NewReader(input io.Reader) *Reader { r := new(Reader) r.Reset(input) return r } // Reset discards the current state and starts reading a new stream from r. // This permits reusing a Reader rather than allocating a new one. func (r *Reader) Reset(input io.Reader) { r.r = input // Several fields are preserved to avoid allocation. // Others are always set before they are used. r.sawFramout information. // Instead, if we've seen the task begin, just make sure the task end lines up. t := ev.Task() if typ, ok := v.tasks[t.ID]; ok { if t.Type != typ { e.Errorf("task end type %q doesn't match task start type %q for task %d", t.Type, typ, t.ID) } delete(v.tasks, t.ID) } case trace.EventLog: // There's really not much here to check, except that we can // generate a Log. The category and message are entirely user-created, // so we can't make any assumptions as to what they are. We also // ca caller // should attempt to advance with other candidate events from other threads. If the // caller runs out of candidates, the trace is invalid. // // If this returns true, Next is guaranteed to return a complete event. However, // multiple events may be added to the ordering, so the caller should (but is not // required to) continue to call Next until it is exhausted. func (o *ordering) Advance(ev *baseEvent, evt *evTable, m ThreadID, gen uint64) (bool, error) { if o.initialGen == 0 { // Set the initial gen if necessary. osume(buf, int64(n)) return int64(n), err } // WriteTo wraps the sendto network call. func (fd *FD) WriteTo(buf []byte, sa syscall.Sockaddr) (int, error) { if err := fd.writeLock(); err != nil { return 0, err } defer fd.writeUnlock() if len(buf) == 0 { // handle zero-byte payload o := &fd.wop o.InitBuf(buf) o.sa = sa n, err := execIO(o, func(o *operation) error { return syscall.WSASendto(o.fd.Sysfd, &o.buf, 1, &o.qty, 0, o.sa, &o.o, nil) }) return n, err } ntotal := 0 for len(buf) > 0 { b := buf if bc_gai_strerror gai_strerror "/usr/lib/libSystem.B.dylib" func libc_gai_strerror_trampoline() func GaiStrerror(ecode int) string { r1, _, _ := syscall_syscall(abi.FuncPCABI0(libc_gai_strerror_trampoline), uintptr(ecode), 0, 0) return GoString((*byte)(unsafe.Pointer(r1))) } // Implemented in the runtime package. func gostring(*byte) string func GoString(p *byte) string { return gostring(p) } //go:linkname syscall_syscall syscall.syscall func syscall_syscall(fn, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) //goes not account for the effect of any symbolic links // that may exist in the filesystem. func IsLocal(path string) bool { return filepathlite.IsLocal(path) } // Localize converts a slash-separated path into an operating system path. // The input path must be a valid path as reported by [io/fs.ValidPath]. // // Localize returns an error if the path cannot be represented by the operating system. // For example, the path a\b is rejected on Windows, on which \ is a separator // character and cannot be part of a filename. // // The pa, 0, false) if string(x.utoa(10)) != pi { panic("benchmark incorrect: conversion failed") } b.RunParallel(func(pb *testing.PB) { for pb.Next() { x.utoa(10) } }) } func BenchmarkScan(b *testing.B) { const x = 10 for _, base := range []int{2, 8, 10, 16} { for _, y := range []Word{10, 100, 1000, 10000, 100000} { if isRaceBuilder && y > 1000 { continue } b.Run(fmt.Sprintf("%d/Base%d", y, base), func(b *testing.B) { b.StopTimer() var z nat z = z.expWW(x, y) s := z.utoa(base) if t := it count, and a read or syntax error err, if any. // // For base 0, an underscore character “_” may appear between a base // prefix and an adjacent digit, and between successive digits; such // underscores do not change the value of the number, or the returned // digit count. Incorrect placement of underscores is reported as an // error if there are no other errors. If base != 0, underscores are // not recognized and thus terminate scanning like any other character // that is not a valid radix point or digit. // // number = ma { return x.AppendText(nil) } // UnmarshalText implements the [encoding.TextUnmarshaler] interface. // The result is rounded per the precision and rounding mode of z. // If z's precision is 0, it is changed to 64 before rounding takes // effect. func (z *Float) UnmarshalText(text []byte) error { // TODO(gri): get rid of the []byte/string conversion _, _, err := z.Parse(string(text), 0) if err != nil { err = fmt.Errorf("math/big: cannot unmarshal %q into a *big.Float (%v)", text, err) } return err } // Copyright 2016 The Gohi, z1lo := bits.Mul64(z1, ix) z0lo := z0 * ix lo, c := bits.Add64(z1lo, z2hi, 0) hi, _ := bits.Add64(z0lo, z1hi, c) // The top 3 bits are j. j = hi >> 61 // Extract the fraction and find its magnitude. hi = hi<<3 | lo>>61 lz := uint(bits.LeadingZeros64(hi)) e := uint64(bias - (lz + 1)) // Clear implicit mantissa bit and shift into place. hi = (hi << (lz + 1)) | (lo >> (64 - (lz + 1))) hi >>= 64 - shift // Include the exponent and convert to a float. hi |= e << shift z = Float64frombits(hi) // Map zeros to origin. ns the complementary error function of the argument. // // Special cases are: // Erfc(+Inf) = 0 // Erfc(-Inf) = 2 // Erfc(NaN) = NaN // The algorithm used is minimax polynomial approximation // with coefficients determined with a Remez exchange algorithm. // This assembly implementation handles inputs in the range [-2.11, +15]. // For all other inputs we call the generic Go implementation. TEXT ·erfcAsm(SB), NOSPLIT|NOFRAME, $0-16 MOVD x+0(FP), R1 MOVD $Neg2p11, R2 CMPUBGT R1, R2, usego FMOVD x+0(FP), F0 MOVDtyp.Kind() { case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Pointer, reflect.Slice: return true case reflect.Struct: return typ == reflectValueType } return false } // validateType guarantees that the value is valid and assignable to the type. func (s *state) validateType(value reflect.Value, typ reflect.Type) reflect.Value { if !value.IsValid() { if typ == nil { // An untyped nil interface{}. Accept as a proper nil value. return reflect.ValueOf(nil) } if canBeNil(typ) { // Like abts { if got := tt.ipp.String(); got != tt.want { t.Errorf("(%#v).String() = %q want %q", tt.ipp, got, tt.want) } } } func TestAsSlice(t *testing.T) { tests := []struct { in Addr want []byte }{ {in: Addr{}, want: nil}, {in: mustIP("1.2.3.4"), want: []byte{1, 2, 3, 4}}, {in: mustIP("ffff::1"), want: []byte{0xff, 0xff, 15: 1}}, } for _, test := range tests { got := test.in.AsSlice() if !bytes.Equal(got, test.want) { t.Errorf("%v.AsSlice() = %v want %v", test.in, got, test.want) } } } var sink16 [16ction which modifies // the request into a new request to be sent // using Transport. Its response is then copied // back to the original client unmodified. // Director must not access the provided Request // after returning. // // By default, the X-Forwarded-For header is set to the // value of the client IP address. If an X-Forwarded-For // header already exists, the client IP is appended to the // existing values. As a special case, if the header // exists in the Request.Header map but has a nil value // (such as wheepeat([]byte{'x'}, 2500), rbuf) { fatalf("ReadFull didn't read 2500 'x'; got %q", string(rbuf)) } resp.Body.Close() rest, err := io.ReadAll(bufr) checkErr(err, "ReadAll on remainder") if e, g := "Next Request Here", string(rest); e != g { g = regexp.MustCompile(`(xx+)`).ReplaceAllStringFunc(g, func(match string) string { return fmt.Sprintf("x(repeated x%d)", len(match)) }) fatalf("remainder = %q, expected %q", g, e) } } } func diff(t *testing.T, prefix string, have, want any) { t.Helper() hv := refl "Content-Length: 0\r\n" + "\r\n", }, // Request with a 0 ContentLength and a 1 byte body. 8: { Req: Request{ Method: "POST", URL: mustParseURL("/"), Host: "example.com", ProtoMajor: 1, ProtoMinor: 1, ContentLength: 0, // as if unset by user }, Body: func() io.ReadCloser { return io.NopCloser(io.LimitReader(strings.NewReader("xx"), 1)) }, WantWrite: "POST / HTTP/1.1\r\n" + "Host: example.com\r\n" + "User-Agent: Go-http-client/1.1\r\n" + "Transfer-Encoding: LSConnectionState(t *testing.T, mode testMode) { ts := newClientServerTest(t, mode, HandlerFunc(func(w ResponseWriter, r *Request) { w.Write([]byte("Hello")) })).ts c := ts.Client() tr := c.Transport.(*Transport) tr.TLSClientConfig.CipherSuites = []uint16{tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256} tr.TLSClientConfig.MaxVersion = tls.VersionTLS12 // to get to pick the cipher suite tr.Dial = func(netw, addr string) (net.Conn, error) { return net.Dial(netw, ts.Listener.Addr().String()) } res, err := c.Get("https://exampl if !supportsIPv4() || !*testIPv4 { t.Skip("IPv4 is required") } mustHaveExternalNetwork(t) defer dnsWaitGroup.Wait() for i, fn := range []func() func(){forceGoDNS, forceCgoDNS} { fixup := fn() if fixup == nil { continue } names, err := LookupAddr("127.0.0.1") fixup() if err != nil { t.Logf("#%d: %v", i, err) continue } mode := "netgo" if i == 1 { mode = "netcgo" } loop: for i, name := range names { if strings.Index(name, ".") == len(name)-1 { // "localhost" not "localhost." for j.Fatal("exchange failed:", err) } } // Issue 27763: verify that two strings in one TXT record are concatenated. func TestTXTRecordTwoStrings(t *testing.T) { fake := fakeDNSServer{ rh: func(n, _ string, q dnsmessage.Message, _ time.Time) (dnsmessage.Message, error) { r := dnsmessage.Message{ Header: dnsmessage.Header{ ID: q.Header.ID, Response: true, RCode: dnsmessage.RCodeSuccess, }, Questions: q.Questions, Answers: []dnsmessage.Resource{ { Header: dnsmessage.ResourceHeaderErrorf("failed to parse error: %v", perr) } if !isDeadlineExceeded(err) { t.Errorf("error is not 'deadline exceeded'") } if n != 0 { t.Errorf("unexpectedly wrote %d bytes", n) } if !t.Failed() { t.Logf("WriteTo timed out as expected") } nDeadlineExceeded++ } }) } } const ( // minDynamicTimeout is the minimum timeout to attempt for // tests that automatically increase timeouts until success. // // Lower values may allow tests to succeed more quickly if the value is close // ([]byte, 64) c.SetReadDeadline(time.Now().Add(100 * time.Millisecond)) n, from, err := c.ReadFrom(b) if err != nil { t.Fatal(err) } if from != nil { t.Fatalf("unexpected peer address: %v", from) } if !bytes.Equal(b[:n], data[:]) { t.Fatalf("got %v; want %v", b[:n], data[:]) } } func TestUnixgramZeroBytePayload(t *testing.T) { if !testableNetwork("unixgram") { t.Skip("unixgram test") } c1 := newLocalPacketListener(t, "unixgram") defer os.Remove(c1.LocalAddr().String()) defer c1.Close() c2, err := Dial("unixg376: 0x0001, 0x377: 0x0001, 0x378: 0x0001, 0x379: 0x0001, 0x37a: 0x0001, 0x37b: 0x0001, 0x37c: 0x0001, 0x37d: 0x0001, 0x37e: 0x0001, 0x37f: 0x0001, // Block 0xe, offset 0x380 0x380: 0x0005, 0x381: 0x0005, 0x382: 0x0005, 0x383: 0x0005, 0x384: 0x0005, 0x385: 0x0005, 0x386: 0x000a, 0x387: 0x000a, 0x388: 0x000d, 0x389: 0x0004, 0x38a: 0x0004, 0x38b: 0x000d, 0x38c: 0x0006, 0x38d: 0x000d, 0x38e: 0x000a, 0x38f: 0x000a, 0x390: 0x000c, 0x391: 0x000c, 0x392: 0x000c, 0x393: 0x000c, 0x394: 0x000c, 0x395: 0x000c, 0x396: 0x000c, 0x397: 0x00, 0x9D, 0x29, 0x45, 0x28, 0xE7, 0xA5, 0xAD, 0x29, 0x45, 0x28, 0xE8, 0x87, 0xAA, 0x29, 0x45, 0x28, 0xE8, 0x87, 0xB3, 0x29, 0x45, 0x28, 0xE8, 0xB2, 0xA1, 0x29, 0x45, 0x28, 0xE8, 0xB3, 0x87, 0x29, 0x45, 0x28, 0xE9, 0x87, 0x91, 0x29, // Bytes 2180 - 21bf 0x45, 0x30, 0xE2, 0x81, 0x84, 0x33, 0x45, 0x31, 0x30, 0xE6, 0x97, 0xA5, 0x45, 0x31, 0x30, 0xE6, 0x9C, 0x88, 0x45, 0x31, 0x30, 0xE7, 0x82, 0xB9, 0x45, 0x31, 0x31, 0xE6, 0x97, 0xA5, 0x45, 0x31, 0x31, 0xE6, 0x9C, 0x88, 0x45, 0x31, 0x31, 0xE7, 0x82, 0xB9, 0x45, 0x31, 0x32, 0xE6,0b\x03\x0a,>\x03\x0a4#\x03\x08%\x17\x03" + "\x07\x05\x22\x03\x07\x0c\x0b\x03\x0a\x1d+\x03\x0a\x19\x16\x03\x09+\x1f" + "\x03\x09\x08\x0b\x03\x08\x16\x18\x03\x08+\x12\x03\x0b\x1d\x0c\x03\x0a=" + "\x10\x03\x0a\x09\x0d\x03\x0a\x10\x11\x03\x09&0\x03\x08(\x1f\x03\x087\x07" + "\x03\x08\x185\x03\x07'6\x03\x06.\x05\x03\x06=\x04\x03\x06;;\x03\x06\x06," + "\x03\x0b\x18>\x03\x08\x00\x18\x03\x06 \x03\x03\x06<\x00\x03\x09%\x18\x03" + "\x0b\x1c<\x03\x0a%!\x03\x0a\x09\x12\x03\x0a\x16\x02\x03\x090'\x03\x09" + "\x0e=\x03\x08 \x0e\x03\x08>\x030x3bc: 0xe00d, 0x3bd: 0x0008, 0x3be: 0xe00d, 0x3bf: 0x0008, // Block 0xf, offset 0x3c0 0x3c0: 0x0040, 0x3c1: 0xe01d, 0x3c2: 0x0008, 0x3c3: 0xe03d, 0x3c4: 0x0008, 0x3c5: 0xe01d, 0x3c6: 0x0008, 0x3c7: 0xe07d, 0x3c8: 0x0008, 0x3c9: 0xe01d, 0x3ca: 0x0008, 0x3cb: 0xe03d, 0x3cc: 0x0008, 0x3cd: 0xe01d, 0x3ce: 0x0008, 0x3cf: 0x0008, 0x3d0: 0xe00d, 0x3d1: 0x0008, 0x3d2: 0xe00d, 0x3d3: 0x0008, 0x3d4: 0xe00d, 0x3d5: 0x0008, 0x3d6: 0xe00d, 0x3d7: 0x0008, 0x3d8: 0xe00d, 0x3d9: 0x0008, 0x3da: 0xe00d, 0x3db: 0x0008, 0x3dc: 0xe00d, 0x3dd: 0x<>+0(SB), R13 MOVOU (SI), X12 ADDQ BX, SI PAND -16(R13)(R9*1), X12 MOVO X12, 64(BP) MOVQ X12, R13 MOVQ 72(BP), R14 PXOR X1, X12 // We can only store one byte at a time, since plaintext can be shorter than 16 bytes openSSETail16Store: MOVQ X12, R8 MOVB R8, (DI) PSRLDQ $0x01, X12 INCQ DI DECQ BX JNE openSSETail16Store ADDQ R13, R10 ADCQ R14, R11 ADCQ $0x01, R12 MOVQ (BP), AX MOVQ AX, R15 MULQ R10 MOVQ AX, R13 MOVQ DX, R14 MOVQ (BP), AX MULQ R11 IMULQ R12, R15 ADDQ AX,f %v", value) } func TestMakeClonesStrings(t *testing.T) { s := strings.Clone("abcdefghijklmnopqrstuvwxyz") // N.B. Must be big enough to not be tiny-allocated. ran := make(chan bool) runtime.SetFinalizer(unsafe.StringData(s), func(_ *byte) { ran <- true }) h := Make(s) // Clean up s (hopefully) and run the finalizer. runtime.GC() select { case <-time.After(1 * time.Second): t.Fatal("string was improperly retained") case <-ran: } runtime.KeepAlive(h) } func TestHandleUnsafeString(t *testing.T) { var testData [] // Action graph execution methods related to coverage. package work import ( "cmd/go/internal/base" "cmd/go/internal/cfg" "cmd/go/internal/str" "cmd/internal/cov/covcmd" "context" "encoding/json" "fmt" "internal/coverage" "io" "os" "path/filepath" ) // CovData invokes "go tool covdata" with the specified arguments // as part of the execution of action 'a'. func (b *Builder) CovData(a *Action, cmdargs ...any) ([]byte, error) { cmdline := str.StringList(cmdargs...) args := append([]string{}, cfg.BuildToolexec...) ah *authHandler) Available() bool { return true } func (h *authHandler) Handler(dir string, env []string, logger *log.Logger) (http.Handler, error) { fs := http.Dir(dir) handler := http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) { urlPath := req.URL.Path if urlPath != "" && strings.HasPrefix(path.Base(urlPath), ".") { http.Error(w, "filename contains leading dot", http.StatusBadRequest) return } f, err := fs.Open(urlPath) if err != nil { if os.IsNotExist(err) { http.NotFound(w, req) } e if !isValidSum(data) { return "" } return string(data) } // isValidSum returns true if data is the valid contents of a zip hash file. // Certain critical files are written to disk by first truncating // then writing the actual bytes, so that if the write fails // the corrupt file should contain at least one of the null // bytes written by the truncate operation. func isValidSum(data []byte) bool { if bytes.IndexByte(data, '\000') >= 0 { return false } if len(data) != len("h1:")+base64.StdEncoding.EncodedLen(sha256.Sizeh.Join("overlay_symlink", "file")}}, } for _, tc := range testCases { t.Run(tc.name, func(t *testing.T) { var got []string err := WalkDir(tc.dir, func(path string, d fs.DirEntry, err error) error { t.Logf("walk %q", path) got = append(got, path) if err != nil { t.Errorf("walkfn: got non nil err argument: %v, want nil err argument", err) } return nil }) if err != nil { t.Errorf("Walk: got error %q, want nil", err) } if !reflect.DeepEqual(got, tc.wantFiles) { t.Errorf("files edule() if rs.hasRedundantRoot() { // If any module path appears more than once in the roots, we know that the // go.mod file needs to be updated even though we have not yet loaded any // transitive dependencies. var err error rs, err = updateRoots(ctx, rs.direct, rs, nil, nil, false) if err != nil { return nil, err } } if MainModules.Index(mainModule).goVersion == "" && rs.pruning != workspace { // TODO(#45551): Do something more principled instead of checking // cfg.CmdName directly here. if cfg.BuildMo.resolvedVersion { m := module.Version{Path: path, Version: reason.version} relevantMods[m] |= resolved } // Reload packages, reporting errors for missing and ambiguous imports. if len(pkgPatterns) > 0 { // LoadPackages will print errors (since it has more context) but will not // exit, since we need to load retractions later. pkgOpts := modload.PackageOpts{ VendorModulesInGOROOTSrc: true, LoadTests: *getT, ResolveMissingImports: false, AllowErrors: true, SilenceNoGoErrorsnd example.net/ambiguous/nested v0.1.0 package pkg golang.org/toolchain@v0.0.1-go1.999testmod.plan9-amd64 -- .mod -- module golang.org/toolchain -- .info -- {"Version":"v0.0.1-go1.999testmod.plan9-amd64"} -- go.mod -- module golang.org/toolchain -- bin/go -- #!/bin/rc echo go1.999testmod here! -- bin/gofmt -- echo i am unused -- pkg/tool/fake -- -- lib/wasm/go_js_wasm_exec -- Module with a function that prints file name for the top stack frame. Different versions of this module are identical, but they should return different file skip [!git] skip env GO111MODULE=on env GOPROXY=direct env GOSUMDB=off env GOFLAGS=-mod=mod # Regression test for golang.org/issue/27173: if the user (or go.mod file) # requests a pseudo-version that does not match both the module path and commit # metadata, reject it with a helpful error message. # # TODO(bcmills): Replace the github.com/pierrec/lz4 examples with something # equivalent on vcs-test.golang.org. # An incomplete commit hash is not a valid semantic version, # but can appear in the main go.mod file anyway and shouldformatting directive' -- go.work -- go 1.18 use ./a -- a/go.mod -- module example.com/a go 1.18 -- a/a.go -- package a import "fmt" func A() { fmt.Println("%s") }[short] skip ! go test -x coverbad ! stderr '[\\/]coverbad\.test( |$)' # 'go test' should not claim to have run the test. stderr 'undefined: g' [cgo] stderr 'undefined: j' -- go.mod -- module coverbad go 1.16 -- p.go -- package p func f() { g() } -- p1.go -- package p import "C" func h() { j() } -- p_test.go -- package p import "testing" func Test(t *tesrsc.io/quote v1.4.0' # Replacements should allow 'go get' to work even with dotless module paths. cp go.mod.orig go.mod ! go list example stderr '^package example is not in std \(.*\)$' ! go get example stderr '^go: malformed module path "example": missing dot in first path element$' go mod edit -replace example@v0.1.0=./example ! go list example stderr '^module example provides package example and is replaced but not required; to add it:\n\tgo get example@v0.1.0$' go get example go list -m example stdout '^example v0.1.0 ' e) that would cause it to be interpreted // differently than if it were the main module. The module must not require // a higher version of itself. // // - Vendor directories are not used in any module. (Vendor directories are not // included in the module zip files downloaded by 'go install'.) // // If the arguments don't have version suffixes, "go install" may run in // module-aware mode or GOPATH mode, depending on the GO111MODULE environment // variable and the presence of a go.mod file. See 'go help modules' for details. // Ifbbrev table for all objects); the number * of abbrev entries is fairly small (compared to C++ objects). The DWARF * spec places no restriction on the ordering of attributes in the * Abbrevs and DIEs, and we will always write them out in the order * of declaration in the abbrev. */ type dwAttrForm struct { attr uint16 form uint8 } // Go-specific type attributes. const ( DW_AT_go_kind = 0x2900 DW_AT_go_key = 0x2901 DW_AT_go_elem = 0x2902 // Attribute for DW_TAG_member of a struct type. // Nonzero value indicates the stsym@GOT, Rx or REGTMP2; MOVD $(Rx or REGTMP2), Rx if p.To.Type != obj.TYPE_REG || p.As != AMOVD { c.ctxt.Diag("do not know how to handle LEA-type insn to non-register in %v with -dynlink", p) } p.From.Type = obj.TYPE_MEM p.From.Name = obj.NAME_GOTREF q := p if p.From.Offset != 0 { target := p.To.Reg if target == REG_R0 { // Cannot use R0 as input to address calculation. // REGTMP might be used by the assembler. p.To.Reg = REGTMP2 } q = obj.Appendp(q, c.newprog) q.As = AMOVD q.From.T uint8 type_ uint8 size int8 param int16 flag int8 pcrelsiz uint8 scond uint8 // optional flags accepted by the instruction } type Opcross [32][2][32]uint8 const ( LFROM = 1 << 0 LTO = 1 << 1 LPOOL = 1 << 2 LPCREL = 1 << 3 ) var optab = []Optab{ /* struct Optab: OPCODE, from, prog->reg, to, type, size, param, flag, extra data size, optional suffix */ {obj.ATEXT, C_ADDR, C_NONE, C_TEXTSIZE, 0, 0, 0, 0, 0, 0}, {AADD, C_REG, C_REG, C_REG, 1, 4, 0, 0, 0, C_SBIT}, {AADD, C_REG, C_NONE, C_REG, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN // THE SOFTWARE. package x86 import ( "cmd/internal/obj" "cmd/internal/objabi" "cmd/internal/sys" "encoding/binary" "fmt" "internal/buildcfg" "log" "strings" ) var ( plan9privates *obj.LSym ) // Instruction layout. // Loop alignment constants: // want to align loop entry to loopAlign-byte boundary, // and willing to insert at most maxLoopPad bytes of NOP to do so. // We defi.mu.Lock() defer ft.mu.Unlock() if fnstate, found := ft.precursor[fnsym]; found { return fnstate.absfn } ft.ctxt.Diag("internal error: AbsFuncDwarfSym requested for %v, not seen during inlining", fnsym) return nil } // Called after all functions have been compiled; the main job of this // function is to identify cases where there are outstanding fixups. // This scenario crops up when we have references to variables of an // inlined routine, but that routine is defined in some other package. // This helper walks through andtedEOF) return 0 } b, err := r.b.ReadByte() if err != nil { if err == io.EOF { err = io.ErrUnexpectedEOF } r.error(err) b = 0 } else { r.offset++ } return b } // readFull reads exactly len(b) bytes from the input file. // If an error occurs, read returns the error but also // records it, so it is safe for callers to ignore the result // as long as delaying the report is not a problem. func (r *objReader) readFull(b []byte) error { if r.err != nil { return r.err } if r.offset+int64(len(b)) > r.limit { re(at least for now) those are modified in place // to switch between the host and target configurations when cross-compiling. func toolenv() []string { var env []string if !mustLinkExternal(goos, goarch, false) { // Unless the platform requires external linking, // we disable cgo to get static binaries for cmd/go and cmd/pprof, // so that they work on systems without the same dynamic libraries // as the original build system. env = append(env, "CGO_ENABLED=0") } if isRelease || os.Getenv("GO_BUILDER_NAME") != "" { //"), at.Element.goString(indent+2, "Element: ")) } // FunctionType is a function type. type FunctionType struct { Return AST Args []AST // The forLocalName field reports whether this FunctionType // was created for a local name. With the default GNU demangling // output we don't print the return type in that case. ForLocalName bool } func (ft *FunctionType) print(ps *printState) { retType := ft.Return if ft.ForLocalName && (!ps.enclosingParams || !ps.llvmStyle) { retType = nil } if retType != nil { // Pass the rng through the profile mappings, it will only examine the ones that have // samples and are matched to the regexp. fileHasSamplesAndMatched := make(map[string]bool) for _, n := range g.Nodes { if name := n.Info.PrintableName(); rx.MatchString(name) && n.Info.Objfile != "" { fileHasSamplesAndMatched[n.Info.Objfile] = true } } // Walk all mappings looking for matching functions with samples. var objSyms []*objSymbol for _, m := range prof.Mapping { // Skip the mapping if its file does not have samples or is not match: zhHansIndex} TraditionalChinese Tag = Tag{language: zhHantIndex, locale: zhHantIndex} Zulu Tag = Tag{language: zuIndex, locale: zuIndex} ) // Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT. package compact // parents maps a compact index of a tag to the compact index of the parent of // this tag. var parents = []ID{ // 775 elements // Entry 0 - 3F 0x0000, 0x0000, 0x0001, 0x0001, 0x0000, 0x0004, 0x0000, 0x0006, 0x0000, 0x0008, 0x0000, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x0042, 0xD7, 0xAA, 0x42, 0xD8, 0xA1, 0x42, 0xD8, 0xA7, 0x42, 0xD8, 0xA8, 0x42, 0xD8, 0xA9, 0x42, 0xD8, 0xAA, 0x42, 0xD8, 0xAB, 0x42, 0xD8, 0xAC, 0x42, 0xD8, // Bytes 340 - 37f 0xAD, 0x42, 0xD8, 0xAE, 0x42, 0xD8, 0xAF, 0x42, 0xD8, 0xB0, 0x42, 0xD8, 0xB1, 0x42, 0xD8, 0xB2, 0x42, 0xD8, 0xB3, 0x42, 0xD8, 0xB4, 0x42, 0xD8, 0xB5, 0x42, 0xD8, 0xB6, 0x42, 0xD8, 0xB7, 0x42, 0xD8, 0xB8, 0x42, 0xD8, 0xB9, 0x42, 0xD8, 0xBA, 0x42, 0xD9, 0x81, 0x42, 0xD9, 0x82, 0x42, 0xD9, 0x83, 0x42, 0xD9, 0x84, 0x42, 0xD9, 0x85, 0x42, 0xD9, 0x86, 0x4243, 0xE6, 0xBA, 0x9C, 0x43, 0xE6, 0xBA, 0xBA, 0x43, 0xE6, 0xBB, 0x87, 0x43, 0xE6, 0xBB, 0x8B, 0x43, 0xE6, 0xBB, 0x91, 0x43, 0xE6, 0xBB, 0x9B, 0x43, 0xE6, 0xBC, 0x8F, 0x43, 0xE6, 0xBC, 0x94, 0x43, 0xE6, 0xBC, 0xA2, 0x43, 0xE6, 0xBC, 0xA3, 0x43, 0xE6, 0xBD, 0xAE, 0x43, 0xE6, 0xBF, 0x86, 0x43, 0xE6, 0xBF, 0xAB, 0x43, 0xE6, 0xBF, 0xBE, 0x43, // Bytes e80 - ebf 0xE7, 0x80, 0x9B, 0x43, 0xE7, 0x80, 0x9E, 0x43, 0xE7, 0x80, 0xB9, 0x43, 0xE7, 0x81, 0x8A, 0x43, 0xE7, 0x81, 0xAB, 0x43, 0xE7, 0x81, 0xB0, 0x43, 0xE7, 0x81, 0xB7, 0x43offset 0x4e {value: 0x3013, lo: 0x80, hi: 0x8f}, {value: 0x6853, lo: 0x90, hi: 0x96}, {value: 0x0014, lo: 0x99, hi: 0x99}, {value: 0x0010, lo: 0x9a, hi: 0x9c}, {value: 0x0010, lo: 0x9e, hi: 0x9e}, {value: 0x0054, lo: 0x9f, hi: 0x9f}, {value: 0x0012, lo: 0xa0, hi: 0xa0}, {value: 0x6552, lo: 0xa1, hi: 0xaf}, {value: 0x3012, lo: 0xb0, hi: 0xbf}, // Block 0xd, offset 0x57 {value: 0x0034, lo: 0x81, hi: 0x82}, {value: 0x0024, lo: 0x84, hi: 0x84}, {value: 0x0034, lo: 0x85, hi: 0x85}, {value: 0x0034, lo: 0x87, hi: 0x87}, {vao = uint32(i)<<6 + uint32(c2) i = caseIndex[o] c3 := s[3] if c3 < 0x80 || 0xC0 <= c3 { return 0, 3 // Illegal UTF-8: not a continuation byte. } return t.lookupValue(uint32(i), c3), 4 } // Illegal rune return 0, 1 } // lookupUnsafe returns the trie value for the first UTF-8 encoding in s. // s must start with a full and valid UTF-8 encoded rune. func (t *caseTrie) lookupUnsafe(s []byte) uint16 { c0 := s[0] if c0 < 0x80 { // is ASCII return caseValues[c0] } i := caseIndex[c0] if c0 < 0xE0 { // 2-byte UTF-8 rg.go.dev/golang.org/x/tools/go/analysis/passes/stdversion", RunDespiteErrors: true, Run: run, } func run(pass *analysis.Pass) (any, error) { // Prior to go1.22, versions.FileVersion returns only the // toolchain version, which is of no use to us, so // disable this analyzer on earlier versions. if !slicesContains(build.Default.ReleaseTags, "go1.22") { return nil, nil } // Don't report diagnostics for modules marked before go1.21, // since at that time the go directive wasn't clearly // specified as a toolpes. // The result may be an alias. // // Use this function to strip off the optional pointer on a receiver // in a field or method selection, without losing the named type // (which is needed to compute the method set). // // See also [typeparams.MustDeref], which removes one level of // indirection from the type, regardless of named types (analogous to // a LOAD instruction). func Unpointer(t types.Type) types.Type { if ptr, ok := types.Unalias(t).(*types.Pointer); ok { return ptr.Elem() } return t } // Copyright 2024 The GoI rd, rs1, imm12 {mask: 0x0000707f, value: 0x00004013, op: XORI, args: argTypeList{arg_rd, arg_rs1, arg_imm12}}, // ZEXT.H rd, rs1 {mask: 0xfff0707f, value: 0x0800403b, op: ZEXT_H, args: argTypeList{arg_rd, arg_rs1}}, } // Code generated by "stringer -type=CSR"; DO NOT EDIT. package riscv64asm import "strconv" 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[USTATUS-0] _ = x[FFLAGS-1] _ = s MOV (register)."}, {"Name":"ORR (shifted register)","Bits":"1|0|1|0|1|0|1|0|shift:2|0|Rm:5|imm6:6|Rn:5|Rd:5","Arch":"64-bit variant","Syntax":"ORR , , {, #}","Code":"","Alias":"This instruction is used by the alias MOV (register)."}, {"Name":"PRFM (immediate)","Bits":"1|1|1|1|1|0|0|1|1|0|imm12:12|Rn:5|Rt:5","Arch":"Unsigned offset variant","Syntax":"PRFM (|#), [{, #}]","Code":"","Alias":""}, {"Name":"PRFM (literal)","Bits":"1|1|0|1|1|0|0|0|imm19:19|Rt:5","Arch":"Literal varianf the symbol containing the target, if any; otherwise it returns "", 0. func GoSyntax(inst Inst, pc uint64, symname SymLookup) string { if symname == nil { symname = func(uint64) (string, uint64) { return "", 0 } } var args []string for i := len(inst.Args) - 1; i >= 0; i-- { a := inst.Args[i] if a == nil { continue } args = append(args, plan9Arg(&inst, pc, symname, a)) } var rep string var last Prefix for _, p := range inst.Prefix { if p == 0 || p.IsREX() || p.IsVEX() { break } switch { // Don't shERTYPE_PUPAT = 0x200 ETHERTYPE_QINQ = 0x88a8 ETHERTYPE_RACAL = 0x7030 ETHERTYPE_RATIONAL = 0x8150 ETHERTYPE_RAWFR = 0x6559 ETHERTYPE_RCL = 0x1995 ETHERTYPE_RDP = 0x8739 ETHERTYPE_RETIX = 0x80f2 ETHERTYPE_REVARP = 0x8035 ETHERTYPE_SCA = 0x6007 ETHERTYPE_SECTRA = 0x86db ETHERTYPE_SECUREDATA = 0x876d ETHERTYPE_SGI000000 CBitFieldMaskBit63 = 0x8000000000000000 ) type SockaddrStorage struct { Family uint16 Data [118]byte _ uint64 } type HDGeometry struct { Heads uint8 Sectors uint8 Cylinders uint16 Start uint64 } type Statfs_t struct { Type int64 Bsize int64 Blocks uint64 Bfree uint64 Bavail uint64 Files uint64 Ffree uint64 Fsid Fsid Namelen int64 Frsize int64 Flags int64 Spare [4]int64 } type TpacketHdr struct { Status uint64 Len uint32 Snaplen uint32 Mac uint16 Net allen := _Socklen(len(buf)) err := getsockopt(fd, level, opt, unsafe.Pointer(&buf[0]), &vallen) if err != nil { return "", err } return ByteSliceToString(buf[:vallen]), nil } //sys recvfrom(fd int, p []byte, flags int, from *RawSockaddrAny, fromlen *_Socklen) (n int, err error) //sys sendto(s int, buf []byte, flags int, to unsafe.Pointer, addrlen _Socklen) (err error) //sys recvmsg(s int, msg *Msghdr, flags int) (n int, err error) func recvmsgRaw(fd int, iov []Iovec, oob []byte, flags int, rsa *RawSockaddrAny) (n, oobn int, 0x10000000 IPV6_TCLASS = 0x2b IPV6_TOKEN_LENGTH = 0x40 IPV6_UNICAST_HOPS = 0x4 IPV6_USE_MIN_MTU = 0x2c IPV6_V6ONLY = 0x25 IPV6_VERSION = 0x60000000 IP_ADDRFORM = 0x16 IP_ADD_MEMBERSHIP = 0xc IP_ADD_SOURCE_MEMBERSHIP = 0x3c IP_BLOCK_SOURCE = 0x3a IP_BROADCAST_IF = 0x10 IP_CACHE_LINE_SIZE = 0x80 IP_DEFAULT_MULTICAST_LOOP = 0x1 IP_DEFAULT_MULTICAST_TTL _THRSLEEP = 94 // { int sys___thrsleep(const volatile void *ident, clockid_t clock_id, const struct timespec *tp, void *lock, const int *abort); } SYS_FSYNC = 95 // { int sys_fsync(int fd); } SYS_SETPRIORITY = 96 // { int sys_setpriority(int which, id_t who, int prio); } SYS_SOCKET = 97 // { int sys_socket(int domain, int type, int protocol); } SYS_CONNECT = 98 // { int sys_connect(int s, const struct sockaddr *name, socklen_t namelen); } SYS_GETDENTS = 99 // { int sys_getdents(int fda, nil case AF_INET6: pp := (*RawSockaddrInet6)(unsafe.Pointer(rsa)) sa := new(SockaddrInet6) p := (*[2]byte)(unsafe.Pointer(&pp.Port)) sa.Port = int(p[0])<<8 + int(p[1]) sa.ZoneId = pp.Scope_id sa.Addr = pp.Addr return sa, nil } return nil, EAFNOSUPPORT } func Gettimeofday(tv *Timeval) (err error) { err = gettimeofday(tv, nil) return } func Sendfile(outfd int, infd int, offset *int64, count int) (written int, err error) { if raceenabled { raceReleaseMerge(unsafe.Pointer(&ioSync)) } return sendfile(outfd,snb Getrlimit(resource int, rlim *Rlimit) (err error) //sys Seek(fd int, offset int64, whence int) (off int64, err error) = lseek //sys mmap(addr uintptr, length uintptr, prot int, flags int, fd int, offset int64) (xaddr uintptr, err error) = mmap64 func setTimespec(sec, nsec int64) Timespec { return Timespec{Sec: sec, Nsec: nsec} } func setTimeval(sec, usec int64) Timeval { return Timeval{Sec: int64(sec), Usec: int32(usec)} } func (iov *Iovec) SetLen(length int) { iov.Len = uint64(length) } func (msghdr *Msghdr) SetControlr = 0x30 SizeofCmsghdr = 0xc SizeofInet6Pktinfo = 0x14 SizeofIPv6MTUInfo = 0x20 SizeofICMPv6Filter = 0x20 ) const ( PTRACE_TRACEME = 0x0 PTRACE_CONT = 0x7 PTRACE_KILL = 0x8 ) type Kevent_t struct { Ident uint64 Filter int16 Flags uint16 Fflags uint32 Data int64 Udata *byte } type FdSet struct { Bits [32]uint32 } const ( SizeofIfMsghdr = 0xa8 SizeofIfData = 0x90 SizeofIfaMsghdr = 0x18 SizeofIfAnnounceMsghdr = 0x1a SizeofRtMsghdr = 0x60scall.Signal(0x1f) ) // Error table var errorList = [...]struct { num syscall.Errno name string desc string }{ {1, "EPERM", "operation not permitted"}, {2, "ENOENT", "no such file or directory"}, {3, "ESRCH", "no such process"}, {4, "EINTR", "interrupted system call"}, {5, "EIO", "input/output error"}, {6, "ENXIO", "no such device or address"}, {7, "E2BIG", "argument list too long"}, {8, "ENOEXEC", "exec format error"}, {9, "EBADF", "bad file descriptor"}, {10, "ECHILD", "no child processes"}, {11, "EAGAIN", "resourhar *attrname, void *data, size_t nbytes); } SYS_EXTATTR_DELETE_FD = 373 // { int extattr_delete_fd(int fd, int attrnamespace, const char *attrname); } SYS___SETUGID = 374 // { int __setugid(int flag); } SYS_EACCESS = 376 // { int eaccess(char *path, int amode); } SYS_NMOUNT = 378 // { int nmount(struct iovec *iovp, unsigned int iovcnt, int flags); } SYS___MAC_GET_PROC = 384 // { int __mac_get_proc(struct mac *mac_p); } SYS___MAC_SET_PROC = 385 // { ruct { Msglen uint16 Version uint8 Type uint8 Index uint16 Pad_cgo_0 [2]byte Flags int32 Addrs int32 Pid int32 Seq int32 Errno int32 Use int32 Inits int32 Pad_cgo_1 [4]byte Rmx RtMetrics } type RtMetrics struct { Locks uint64 Mtu uint64 Hopcount uint64 Recvpipe uint64 Sendpipe uint64 Ssthresh uint64 Rtt uint64 Rttvar uint64 Expire int64 Pksent int64 } type Mclpool [0]byte const ( SizeofBpfVersion = 0x4 SizeofBpfStat = 0x80 Size} SYS_MUNLOCK = 204 // { int|sys||munlock(const void *addr, size_t len); } SYS_UNDELETE = 205 // { int|sys||undelete(const char *path); } SYS_GETPGID = 207 // { pid_t|sys||getpgid(pid_t pid); } SYS_REBOOT = 208 // { int|sys||reboot(int opt, char *bootstr); } SYS_POLL = 209 // { int|sys||poll(struct pollfd *fds, u_int nfds, int timeout); } SYS_SEMGET = 221 // { int|sys||semget(key_t key, int nsems, int semflg); } SYS_SEMOP = 222 /); *(*byte)(ptr) != 0; n++ { ptr = unsafe.Pointer(uintptr(ptr) + 1) } return string(unsafe.Slice(p, n)) } // Single-word zero for use when we need a valid pointer to 0 bytes. var _zero uintptr // go run mkasm.go openbsd riscv64 // Code generated by the command above; DO NOT EDIT. #include "textflag.h" TEXT libc_getgroups_trampoline<>(SB),NOSPLIT,$0-0 JMP libc_getgroups(SB) GLOBL ·libc_getgroups_trampoline_addr(SB), RODATA, $8 DATA ·libc_getgroups_trampoline_addr(SB)/8, $libc_getgroups_trampoline<>(SB) TEXT libc_setgroup struct { Family uint16 Data [14]uint8 } type RawSockaddrAny struct { Addr RawSockaddr Pad [96]uint8 } type Iovec struct { Base *byte Len uint64 } type Msghdr struct { Name *byte Namelen uint32 Iov *Iovec Iovlen uint64 Control *byte Controllen uint64 Flags int32 _ [4]byte } type Cmsghdr struct { Len uint64 Level int32 Type int32 } type ifreq struct { Ifrn [16]byte Ifru [24]byte } const ( SizeofSockaddrNFCLLCP = 0x60 SizeofIovec = 0x10 SizeofMsghdr :build linux && ppc package unix import ( "syscall" "unsafe" ) //sys EpollWait(epfd int, events []EpollEvent, msec int) (n int, err error) //sys Fchown(fd int, uid int, gid int) (err error) //sys Fstat(fd int, stat *Stat_t) (err error) = SYS_FSTAT64 //sys Fstatat(dirfd int, path string, stat *Stat_t, flags int) (err error) = SYS_FSTATAT64 //sys Ftruncate(fd int, length int64) (err error) = SYS_FTRUNCATE64 //sysnb Getegid() (egid int) //sysnb Geteuid() (euid int) //sysnb Getgid() (gid int) //sysnb Getuid() (uid int) //sys Ioper, _, e1 := syscall_syscall6(libc_select_trampoline_addr, uintptr(nfd), uintptr(unsafe.Pointer(r)), uintptr(unsafe.Pointer(w)), uintptr(unsafe.Pointer(e)), uintptr(unsafe.Pointer(timeout)), 0) n = int(r0) if e1 != 0 { err = errnoErr(e1) } return } var libc_select_trampoline_addr uintptr //go:cgo_import_dynamic libc_select select "libc.so" // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func Setegid(egid int) (err error) { _, _, e1 := syscall_rawSyscall(libc_setegid_trampoline_addr, uintptr(egid), 0, 0) iMAND AT THE TOP; DO NOT EDIT func socket(domain int, typ int, proto int) (fd int, err error) { r0, _, e1 := RawSyscall(SYS_SOCKET, uintptr(domain), uintptr(typ), uintptr(proto)) fd = int(r0) if e1 != 0 { err = errnoErr(e1) } return } // THIS FILE IS GENERATED BY THE COMMAND AT THE TOP; DO NOT EDIT func getsockopt(s int, level int, name int, val unsafe.Pointer, vallen *_Socklen) (err error) { _, _, e1 := Syscall6(SYS_GETSOCKOPT, uintptr(s), uintptr(level), uintptr(name), uintptr(val), uintptr(unsafe.Pointer(vallen)), 0) DA = 26 AF_BTH = 32 SOCK_STREAM = 1 SOCK_DGRAM = 2 SOCK_RAW = 3 SOCK_RDM = 4 SOCK_SEQPACKET = 5 IPPROTO_IP = 0 IPPROTO_ICMP = 1 IPPROTO_IGMP = 2 BTHPROTO_RFCOMM = 3 IPPROTO_TCP = 6 IPPROTO_UDP = 17 IPPROTO_IPV6 = 41 IPPROTO_ICMPV6 = 58 IPPROTO_RM = 113 SOL_SOCKET = 0xffff SO_REUSEADDR = 4 SO_KEEPALIVE = 8 SO_DONTROUTE = 16 SO_BROADCAST = 32 SO_LINGER = 128 SO_RCVBUF trings.TrimSuffix(filepath.Base(os.Args[0]), ".exe") } // Main module version information is not populated for the cmd module, but // we can re-use the Go version here. if IsToolchainProgram(progPath) { progVers = goVers } else { progVers = info.Main.Version if strings.Contains(progVers, "devel") || strings.Count(progVers, "-") > 1 { // Heuristically mark all pseudo-version-like version strings as "devel" // to avoid creating too many counter files. // We should not use regexp that pulls in large dependencies. f [2404]byte; use(buf[:]); C.callGoStackCheck() } func stack2408() { var buf [2408]byte;// Copyright 2017 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. #include #include #include #include "_cgo_export.h" /* Test calling a Go function with multiple return values. */ void callMulti(void) { struct multi_return result = multi(); assert(strcmp(result.r0, "multi") == 0); assert(result.r1 == 0); free(resucmd := exec.Command("go", "env", "CC", "GOGCCFLAGS") cmd.Dir = modRoot cmd.Stderr = new(strings.Builder) cmd.Env = append(os.Environ(), "GOPATH="+GOPATH) out, err := cmd.Output() if err != nil { t.Fatalf("%s: %v\n%s", strings.Join(cmd.Args, " "), err, cmd.Stderr) } lines := strings.Split(string(out), "\n") if len(lines) != 3 || lines[2] != "" { t.Fatalf("Unexpected output from %s:\n%s", strings.Join(cmd.Args, " "), lines) } cc := lines[0] if cc == "" { t.Fatal("CC environment variable (go env CC) cannot be empty") AddEvent(size int64, unit string) { m := t.events if m == nil { m = make(map[int][]*event) t.events = m } i := len(t.list) if i > 0 { i-- } m[i] = append(m[i], &event{size, unit}) } // Write prints the phase times to w. // The prefix is printed at the start of each line. func (t *Timings) Write(w io.Writer, prefix string) { if len(t.list) > 0 { var lines lines // group of phases with shared non-empty label prefix var group struct { label string // label prefix tot time.Duration // accumulated p9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23}, [8]byte{211, 212, 213, 214, 215, 216, 217, 218}} x := [1024]byte{100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 172, 173, 174, 175, 1es) check( fmt.Sprintf("%v += float64(%v * %v)", t.z, t.x, t.y), func(x, y, z float64) float64 { z += float64(x * y) return z }(t.x, t.y, t.z), t.res) } } { // Test that a multiply-accumulate operation with intermediate // rounding forced by a complex128() cast produces the expected // result. // Test cases generated experimentally on a system (s390x) that // supports fused multiply-add instructions. var tests = [...]struct { x, y float64 res complex128 }{ {0.604660287979619) } } func (n *SelectorExpr) editChildrenWithHidden(edit func(Node) Node) { editNodes(n.init, edit) if n.X != nil { n.X = edit(n.X).(Node) } if n.Prealloc != nil { n.Prealloc = edit(n.Prealloc).(*Name) } } func (n *SendStmt) Format(s fmt.State, verb rune) { fmtNode(n, s, verb) } func (n *SendStmt) copy() Node { c := *n c.init = copyNodes(c.init) return &c } func (n *SendStmt) doChildren(do func(Node) bool) bool { if doNodes(n.init, do) { return true } if n.Chan != nil && do(n.Chan) { return true } if n.Value = src.NoXPos } slices.SortFunc(methods, CompareFields) if int64(len(methods)) >= MaxWidth/int64(PtrSize) { base.ErrorfAt(typePos(t), 0, "interface too large") } for i, m := range methods { m.Offset = int64(i) * int64(PtrSize) } t.SetAllMethods(methods) } // calcStructOffset computes the offsets of a sequence of fields, // starting at the given offset. It returns the resulting offset and // maximum field alignment. func calcStructOffset(t *Type, fields []*Field, offset int64) int64 { for _, f := range fields { Calc(s *state, n *ir.CallExpr, args []*ssa.Value) *ssa.Value { // An empty slot is 1000 0000 // A deleted slot is 1111 1110 // A full slot is 0??? ???? g := args[0] // Explicit copy to fp register. See // https://go.dev/issue/70451. gfp := s.newValue1(ssa.OpAMD64MOVQi2f, types.TypeInt128, g) if buildcfg.GOAMD64 >= 2 { // "PSIGNB negates each data element of the // destination operand (the first operand) if // the signed integer value of the // corresponding data element in the source Expr { init.Append(ir.TakeInit(call)...) if call, ok := call.(*ir.CallExpr); ok && call.Op() == ir.OCALLFUNC { if sig := call.Fun.Type(); sig.NumParams()+sig.NumResults() == 0 { return call // already in normal form } } // Create a new wrapper function without parameters or results. wrapperFn := ir.NewClosureFunc(pos, pos, op, types.NewSignature(nil, nil, nil), ir.CurFunc, Target) wrapperFn.DeclareParams(true) wrapperFn.SetWrapper(true) // argps collects the list of operands within the call expression // that musn).(*ir.IndexExpr) a.X = l a.Index = r return walkExpr(typecheck.Expr(a), init) case ir.OSTRUCTLIT, ir.OARRAYLIT, ir.OSLICELIT: n := n.(*ir.CompLitExpr) if isStaticCompositeLiteral(n) { return n } } // make a copy; must not be used as an lvalue if ir.IsAddressable(n) { base.Fatalf("missing lvalue case in safeExpr: %v", n) } return cheapExpr(n, init) } func copyExpr(n ir.Node, t *types.Type, init *ir.Nodes) ir.Node { l := typecheck.TempAt(base.Pos, ir.CurFunc, t) appendWalkStmt(init, ir.NewAssignStmt(baseackage types2 import "sync/atomic" // Note: This is a uint32 rather than a uint64 because the // respective 64 bit atomic instructions are not available // on all platforms. var lastID atomic.Uint32 // nextID returns a value increasing monotonically by 1 with // each call, starting with 1. It may be called concurrently. func nextID() uint64 { return uint64(lastID.Add(1)) } // A TypeParam represents the type of a type parameter in a generic declaration. // // A TypeParam has a name; use the [TypeParam.Obj] method to access // it're not in a constant declaration } switch s := decl.(type) { case *syntax.ImportDecl: // import package if s.Path == nil || s.Path.Bad { continue // error reported during parsing } path, err := validatedImportPath(s.Path.Value) if err != nil { check.errorf(s.Path, BadImportPath, "invalid import path (%s)", err) continue } imp := check.importPackage(s.Path.Pos(), path, fileDir) if imp == nil { continue } // local name overrides imported package name name := under(typ).(type) { case *Slice, *Signature, *Map: return compositeKind(typ) + " can only be compared to nil" } // see if we can extract a more specific error var cause string comparableType(typ, true, nil, func(format string, args ...interface{}) { cause = check.sprintf(format, args...) }) return cause } // If e != nil, it must be the shift expression; it may be nil for non-constant shifts. func (check *Checker) shift(x, y *operand, e syntax.Expr, op syntax.Operator) { // TODO(gri) This function seems overly complex.LoweredAtomicOr", argLength: 3, reg: gpstore, asm: "OR", faultOnNilArg0: true, hasSideEffects: true, unsafePoint: true}, // large or unaligned zeroing // arg0 = address of memory to zero (in R1, changed as side effect) // arg1 = address of the last element to zero // arg2 = mem // auxint = alignment // returns mem // SUBU $4, R1 // MOVW R0, 4(R1) // ADDU $4, R1 // BNE Rarg1, R1, -2(PC) { name: "LoweredZero", aux: "Int32", argLength: 3, reg: regInfo{ inputs: []regMask{buildReg("R1"m} ptr (MOVWUreg x) mem) => (MOVWstore [off] {sym} ptr x mem) // if a register move has only 1 use, just use the same register without emitting instruction // MOVVnop doesn't emit instruction, only for ensuring the type. (MOVVreg x) && x.Uses == 1 => (MOVVnop x) // TODO: we should be able to get rid of MOVVnop all together. // But for now, this is enough to get rid of lots of them. (MOVVnop (MOVVconst [c])) => (MOVVconst [c]) // fold constant into arithmetic ops (ADDV x (MOVVconst [c])) && is32Bit(c) && !t.IsPtr() => (ADDVcoyp: "Mem"}, // Write barrier code is done, interrupting is now allowed. // WB invokes runtime.gcWriteBarrier. This is not a normal // call: it takes arguments in registers, doesn't clobber // general-purpose registers (the exact clobber set is // arch-dependent), and is not a safe-point. {name: "WB", argLength: 1, typ: "(BytePtr,Mem)", aux: "Int64"}, // arg0=mem, auxint=# of buffer entries needed. Returns buffer pointer and memory. {name: "HasCPUFeature", argLength: 0, typ: "bool", aux: "Sym", symEffect: "reg: gp21, asm: "IMULL", commutative: true, resultInArg0: true, clobberFlags: true}, {name: "MULQconst", argLength: 1, reg: gp11, asm: "IMUL3Q", aux: "Int32", clobberFlags: true}, {name: "MULLconst", argLength: 1, reg: gp11, asm: "IMUL3L", aux: "Int32", clobberFlags: true}, // Let x = arg0*arg1 (full 32x32->64 unsigned multiply). Returns uint32(x), and flags set to overflow if uint32(x) != x. {name: "MULLU", argLength: 2, reg: regInfo{inputs: []regMask{ax, gpsp}, outputs: []regMask{ax, 0}, clobbers: dx}, typ: "(UInt32,Fla { liveMem = w continue } if w != liveMem { return false } } } if v.Type.IsMemory() { liveMem = v } } } return true } func TestStoreOrder(t *testing.T) { // In the function below, v2 depends on v3 and v4, v4 depends on v3, and v3 depends on store v5. // storeOrder did not handle this case correctly. c := testConfig(t) fun := c.Fun("entry", Bloc("entry", Valu("mem0", OpInitMem, types.TypeMem, 0, nil), Valu("a", OpAdd64, c.config.Types.Int64, 0, nil, "b", "c"), } return case OpStore, OpMove, OpZero: // v should be eliminated if we eliminate the auto. n, ok := addr[args[0]] if ok && elim[v] == nil { elim[v] = n changed = true } // Other args might hold pointers to autos. args = args[1:] } // The code below assumes that we have handled all the ops // with sym effects already. Sanity check that here. // Ignore Args since they can't be autos. if v.Op.SymEffect() != SymNone && v.Op != OpArg { panic("unhandled op with sym effect") } if v.Uses =b.Preds) == 0 && b != f.Entry { // Block is now dead. b.Kind = BlockInvalid } } ft.restore() ft.cleanup(f) return changed } // Code generated from _gen/S390X.rules using 'go generate'; DO NOT EDIT. package ssa import "math" import "cmd/compile/internal/types" import "cmd/internal/obj/s390x" func rewriteValueS390X(v *Value) bool { switch v.Op { case OpAdd16: v.Op = OpS390XADDW return true case OpAdd32: v.Op = OpS390XADDW return true case OpAdd32F: return rewriteValueS390X_OpAdd32F(v) case OpAdd64: v.OPos, OpSignExt32to64, typ.Int64) v2.AddArg(y) v0.AddArg2(v1, v2) v.AddArg(v0) return true } break } // match: (Eq32 x y) // cond: !x.Type.IsSigned() // result: (SEQZ (SUB (ZeroExt32to64 x) (ZeroExt32to64 y))) for { for _i0 := 0; _i0 <= 1; _i0, v_0, v_1 = _i0+1, v_1, v_0 { x := v_0 y := v_1 if !(!x.Type.IsSigned()) { continue } v.reset(OpRISCV64SEQZ) v0 := b.NewValue0(v.Pos, OpRISCV64SUB, x.Type) v1 := b.NewValue0(v.Pos, OpZeroExt32to64, typ.UInt64) v1.AddArg(x) v2 := b. {sym} ptr mem) for { off1 := auxIntToInt32(v.AuxInt) sym := auxToSym(v.Aux) x := v_0 if x.Op != OpMIPSADDconst { break } off2 := auxIntToInt32(x.AuxInt) ptr := x.Args[0] mem := v_1 if !(is16Bit(int64(off1+off2)) || x.Uses == 1) { break } v.reset(OpMIPSMOVBload) v.AuxInt = int32ToAuxInt(off1 + off2) v.Aux = symToAux(sym) v.AddArg2(ptr, mem) return true } // match: (MOVBload [off1] {sym1} (MOVWaddr [off2] {sym2} ptr) mem) // cond: canMergeSym(sym1,sym2) // result: (MOVBload [off1+off2] {mergealse } func rewriteValueARM64_OpARM64ADDshiftLL(v *Value) bool { v_1 := v.Args[1] v_0 := v.Args[0] b := v.Block typ := &b.Func.Config.Types // match: (ADDshiftLL (MOVDconst [c]) x [d]) // result: (ADDconst [c] (SLLconst x [d])) for { d := auxIntToInt64(v.AuxInt) if v_0.Op != OpARM64MOVDconst { break } c := auxIntToInt64(v_0.AuxInt) x := v_1 v.reset(OpARM64ADDconst) v.AuxInt = int64ToAuxInt(c) v0 := b.NewValue0(v.Pos, OpARM64SLLconst, x.Type) v0.AuxInt = int64ToAuxInt(d) v0.AddArg(x) v.AddArgj.TYPE_CONST p.To.Offset = v.AuxInt case ssa.OpPPC64MOVWstorezero, ssa.OpPPC64MOVHstorezero, ssa.OpPPC64MOVBstorezero: p := s.Prog(v.Op.Asm()) p.From.Type = obj.TYPE_REG p.From.Reg = ppc64.REGZERO p.To.Type = obj.TYPE_MEM p.To.Reg = v.Args[0].Reg() ssagen.AddAux(&p.To, v) case ssa.OpPPC64MOVDstore, ssa.OpPPC64MOVDstorezero: // MOVDstore and MOVDstorezero become DS form instructions that are restricted // to offset values that are a multiple of 4. If the offset field is not a // multiple of 4, then the full e same size/alignment into a // common type, recursively shaping the element types of composite // types, and discarding struct field names and tags. However, we'll // need to start tracking how type parameters are actually used to // implement some of these optimizations. under := targ.Underlying() if basic && targ.IsPtr() && !targ.Elem().NotInHeap() { under = types.NewPtr(types.Types[types.TUINT8]) } // Hash long type names to bound symbol name length seen by users, // particularly for large protobuf structs (#65030).space required with more available registers. This does, however, suggest that eliminating spill slots in the future would noticeably reduce stack requirements. go run main.go ! stdout . ! stderr . -- main.go -- package main func main() { switch { case true: _: fallthrough default: } switch { case true: _: _: fallthrough default: } } # Test of the linker's script test harness. go build [!cgo] skip cc -c testdata/mumble.c [GOEXPERIMENT:fieldtrack] help exec -- go.mod -- module main go 1.20 -- main.go -- packagc_value=16553288 HeapAlloc dt=6 heapalloc_value=16561480 HeapAlloc dt=5 heapalloc_value=16569672 GoBlock dt=11 reason_string=19 stack=21 ProcStop dt=109 ProcStart dt=18122 p=2 p_seq=12 ProcStop dt=23 ProcStart dt=803 p=1 p_seq=12 GoUnblock dt=12 g=24 g_seq=10 stack=0 GoStart dt=143 g=24 g_seq=11 GoLabel dt=2 label_string=2 GoBlock dt=3389 reason_string=15 stack=27 ProcStop dt=2403 ProcStart dt=161103 p=4 p_seq=8 GoStart dt=172 g=38 g_seq=1 GoStop dt=304901 reason_string=16 stack=50 GoStart dt=21 g=38 g_seq=2 GoStop dt=315468 reasonreturn fmt.Errorf("cannot find __go_fipsinfo") } data, err := sect.Data() if err != nil { return err } uptr := ctxt.Arch.ByteOrder.Uint64 if ctxt.Arch.PtrSize == 4 { uptr = func(x []byte) uint64 { return uint64(ctxt.Arch.ByteOrder.Uint32(x)) } } // Add the sections listed in go:fipsinfo to the FIPS object. // On Mac, the debug/macho package is not reporting any relocations, // but the addends are all in the data already, all relative to // the same base. // Determine the base used for the self pointer, and th/ for _, sect := range Segdwarf.Sections { var dwsize uint64 if ctxt.LinkMode == LinkInternal { // Find the size of this corresponding package DWARF compilation unit. // This size is set during DWARF generation (see dwarf.go). dwsize = getDwsectCUSize(sect.Name, name) // .debug_abbrev is common to all packages and not found with the previous function if sect.Name == ".debug_abbrev" { dwsize = uint64(ldr.SymSize(loader.Sym(sect.Sym))) } } else { // There is only one .FILE with external linking. dw on static analysis, and mark all exported methods of all reachable // types as reachable. // // If the argument to MethodByName is a compile-time constant, the compiler // emits a relocation with the method name. Matching methods are kept in all // reachable types. // // Any unreached text symbols are removed from ctxt.Textp. func deadcode(ctxt *Link) { ldr := ctxt.loader d := deadcodePass{ctxt: ctxt, ldr: ldr} d.init() d.flood() if ctxt.DynlinkingGo() { // Exported methods may satisfy interfaces we don't know // about yelocOffset { ldr.Errorf(s, "unexpected relocation type %d (%s)", r.Type(), sym.RelocName(target.Arch, r.Type())) return false } // Handle relocations found in ELF object files. case objabi.ElfRelocOffset + objabi.RelocType(elf.R_ARM_PLT32): su := ldr.MakeSymbolUpdater(s) su.SetRelocType(rIdx, objabi.R_CALLARM) if targType == sym.SDYNIMPORT { addpltsym(target, ldr, syms, targ) su.SetRelocSym(rIdx, syms.PLT) su.SetRelocAdd(rIdx, int64(braddoff(int32(r.Add()), ldr.SymPlt(targ)/4))) } return true case ternal/objabi" "cmd/internal/src" ) // Input is the main input: a stack of readers and some macro definitions. // It also handles #include processing (by pushing onto the input stack) // and parses and instantiates macro definitions. type Input struct { Stack includes []string beginningOfLine bool ifdefStack []bool macros map[string]*Macro text string // Text of last token returned by Next. peek bool peekToken ScanToken peekText string } // NewInput returns an Inpu/ ERROR "immediate out of range 0 to 31" SD X5, 4294967296(X6) // ERROR "constant 4294967296 too large" SRLI $1, X5, F1 // ERROR "expected integer register in rd position but got non-integer register F1" SRLI $1, F1, X5 // ERROR "expected integer register in rs1 position but got non-integer register F1" FNES F1, (X5) // ERROR "needs an integer register output" RET // Code generated by avx512test. DO NOT EDIT. #include "../../../../../../runtime/textflag.h" TEXT asmtest_avx512dq(SB), NOSPLIT, $0 KADDB K3, K1, K6 , R11 // ADDS $14438400, R3, R11 // 6b1477b1 ADDSW R7->22, R14, R13 // cd59872b ADDS R14>>7, ZR, R4 // e41f4eab AND $-9223372036854775808, R1, R1 // 21004192 ANDW $4026540031, R29, R2 // a2430412 AND $34903429696192636, R12, R19 // 93910e92 ANDW R9@>7, R19, R26 // 7a1ec90a AND R9@>7, R19, R26 // 7a1ec98a TSTW $2863311530, R24 // 1ff30172 TST R2, R0 le != 0 { p.errorf("expected simple register reference") } a.Type = obj.TYPE_REG a.Reg = r1 if r2 != 0 { // Form is R1:R2. It is on RHS and the second register // needs to go into the LHS. panic("cannot happen (Addr.Reg2)") } } // fmt.Printf("REG %s\n", obj.Dconv(&emptyProg, 0, a)) p.expectOperandEnd() return } // Constant. haveConstant := false switch tok.ScanToken { case scanner.Int, scanner.Float, scanner.String, scanner.Char, '+', '-', '~': haveConstant = true case '(': // Couldtes.Buffer w := zlib.NewWriter(&b) w.Write([]byte("hello, world\n")) w.Close() fmt.Println(b.Bytes()) // Output: [120 156 202 72 205 201 201 215 81 40 207 47 202 73 225 2 4 0 0 255 255 33 231 4 147] } func ExampleNewReader() { buff := []byte{120, 156, 202, 72, 205, 201, 201, 215, 81, 40, 207, 47, 202, 73, 225, 2, 4, 0, 0, 255, 255, 33, 231, 4, 147} b := bytes.NewReader(buff) r, err := zlib.NewReader(b) if err != nil { panic(err) } io.Copy(os.Stdout, r) // Output: hello, world r.Close() } // Copyright 2011 The Gox00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, 0x3c, 0x3d, 0x3e, 0x3f, 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49, 0x4a, 0x4b, 0x4c, 0x4d, 0x4e, 0x4f, 0x50, 0x51, 0x52, 0x53, 0x54s means that the code width starts at 8 bits, // which makes it easier to visually inspect the output (provided that the // output is short so codes don't get longer). Each byte is a code: // - ASCII bytes are literal codes, // - 0x80 is the clear code, // - 0x81 is the end code. // - 0x82 and above are copy codes (unused in this test case). for _, empty := range []bool{false, true} { var buf bytes.Buffer w := NewWriter(&buf, LSB, 7) if !empty { w.Write([]byte("Hi")) } w.Close() got := buf.String() wantrrorf("Chunk(%v, %d) = %v, want %v", tc.s, tc.n, chunks, tc.chunks) } if len(chunks) == 0 { return } // Verify that appending to the end of the first chunk does not // clobber the beginning of the next chunk. s := Clone(tc.s) chunks[0] = append(chunks[0], -1) if !Equal(s, tc.s) { t.Errorf("slice was clobbered: %v, want %v", s, tc.s) } }) } } func TestChunkPanics(t *testing.T) { for _, test := range []struct { name string x []struct{} n int }{ { name: "cannot be less than 1 returning not to leak the goroutine case dst <- n: n++ } } }() return dst } ctx, cancel := context.WithCancel(context.Background()) defer cancel() // cancel when we are finished consuming integers for n := range gen(ctx) { fmt.Println(n) if n == 5 { break } } // Output: // 1 // 2 // 3 // 4 // 5 } // This example passes a context with an arbitrary deadline to tell a blocking // function that it should abandon its work as soon as it gets to it. func ExampleWithDeadline() { d := time.Now().mutex": mutexProfile, } } } func unlockProfiles() { profiles.mu.Unlock() } // NewProfile creates a new profile with the given name. // If a profile with that name already exists, NewProfile panics. // The convention is to use a 'import/path.' prefix to create // separate name spaces for each package. // For compatibility with various tools that read pprof data, // profile names should not contain spaces. func NewProfile(name string) *Profile { lockProfiles() defer unlockProfiles() if name == "" { panic("pprof: NewooffffAAAoAooof// Copyright 2022 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. // This package holds the race detector .syso for // amd64 architectures with GOAMD64 @@Cf.Df.T) { ch := make(chan int, 3) a := []int{1, 2, 3} b := []int{4} // used to insert a spurious instrumentation of a[i] // and crash. i := 1 for i, a[i] = range b { ch <- i } close(ch) } func TestRaceRange(t *testing.T) { const N = 2 var a [N]int var x, y int _ = x + y done := make(chan bool, N) var i, v int // declare here (not in for stmt) so that i and v are shared w/ or w/o loop variable sharing change for i, v = range a { go func(i int) { // we don't want a write-vs-write race // so there is no array b hsscall2 TEXT ·set_crosscall2(SB),NOSPLIT,$0-0 MOVD _crosscall2_ptr(SB), R5 MOVD CROSSCALL2_FPTR, R6 MOVD R6, (R5) RET TEXT crosscall2_trampoline<>(SB),NOSPLIT,$0-0 JMP crosscall2(SB) // Called by C code generated by cmd/cgo. // func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr) // Saves C callee-saved registers and calls cgocallback with three arguments. // fn is the PC of a func(a unsafe.Pointer) function. // The value of R2 is saved on the new stack frame, and not // the caller's frame due to issue #43228. TEXT e, }, { Name: "/sync/mutex/wait/total:seconds", Description: "Approximate cumulative time goroutines have spent blocked on a sync.Mutex, sync.RWMutex, or runtime-internal lock. This metric is useful for identifying global changes in lock contention. Collect a mutex or block profile using the runtime/pprof package for more detailed contention data.", Kind: KindFloat64, Cumulative: true, }, } func init() { // Insert all the non-default-reporting GODEBUGs into the table, // preserving the overall sort orde, 0, 0}, }, after: map[ChunkIdx][]BitRange{ baseChunkIdx + sumsPerPhysPage - 1: {{0, PallocChunkPages}}, baseChunkIdx + chunkIdxBigJump: {{0, PallocChunkPages}}, }, } // Test to check for issue #40191. Essentially, the candidate searchAddr // discovered by find may not point to mapped memory, so we need to handle // that explicitly. // // chunkIdxSmallOffset is an offset intended to be used within chunkIdxBigJump. // It is far enough within chunkIdxBigJump that the summaries at the beginning //pyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com). All rights reserved. // Portions Copyright 2009 The Go Authors. All rights reserved. // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to aware of this and will // intentionally increment trap PCs in order to correct // for the decrement performed by // runtime.CallersFrames. See runtime.tracebackPCs and // runtume.(*unwinder).symPC. // // We must emulate the same behavior, otherwise we will // report the location of the instruction immediately // prior to the trap, which may be on a different line, // or even a different inlined functions. // // TODO(prattmic): The runtime applies the same trap // behavior for other "injected callstruct to the max size in the kernel. _ [_sigev_max_size - unsafe.Sizeof(sigeventFields{})]byte } // created by cgo -cdefs and then converted to Go // cgo -cdefs defs_linux.go defs1_linux.go const ( _O_RDONLY = 0x0 _O_WRONLY = 0x1 _O_CREAT = 0x40 _O_TRUNC = 0x200 _O_NONBLOCK = 0x800 _O_CLOEXEC = 0x80000 ) type usigset struct { __val [16]uint64 } type fpxreg struct { significand [4]uint16 exponent uint16 padding [3]uint16 } type xmmreg struct { element [4]uint32 } type fpstate struct { cwd e { // Note: can't use rawmem (which avoids zeroing of memory), because then GC can scan uninitialized memory. p = mallocgc(capmem, et, true) if lenmem > 0 && writeBarrier.enabled { // Only shade the pointers in oldPtr since we know the destination slice p // only contains nil pointers because it has been cleared during alloc. // // It's safe to pass a type to this function as an optimization because // from and to only ever refer to memory representing whole values of // type et. See the comment on bulkBarrd_getaffinity, AX MOVL pid+0(FP), BX MOVL len+4(FP), CX MOVL buf+8(FP), DX INVOKE_SYSCALL MOVL AX, ret+12(FP) RET // int access(const char *name, int mode) TEXT runtime·access(SB),NOSPLIT,$0 MOVL $SYS_access, AX MOVL name+0(FP), BX MOVL mode+4(FP), CX INVOKE_SYSCALL MOVL AX, ret+8(FP) RET // int connect(int fd, const struct sockaddr *addr, socklen_t addrlen) TEXT runtime·connect(SB),NOSPLIT,$0-16 // connect is implemented as socketcall(NR_socket, 3, *(rest of args)) // stack already should have fd, addr, addrlen. et) err = pthread_create(&attr, fn, nil) sigprocmask(_SIG_SETMASK, &oset, nil) if err != 0 { writeErrStr(failthreadcreate) exit(1) } } // Called to do synchronous initialization of Go code built with // -buildmode=c-archive or -buildmode=c-shared. // None of the Go runtime is initialized. // //go:nosplit //go:nowritebarrierrec func libpreinit() { initsig(true) } // Called to initialize a new m (including the bootstrap m). // Called on the parent thread (main thread in case of bootstrap), can allocate memory. func mpreinie.GOOS { case "windows", "plan9": t.Skipf("skipping dropm test on %s", runtime.GOOS) } got := runTestProg(t, "testprogcgo", "EnsureDropM") want := "OK\n" if got != want { t.Errorf("expected %q, got %v", want, got) } } // Test for issue 14387. // Test that the program that doesn't need any cgo pointer checking // takes about the same amount of time with it as without it. func TestCgoCheckBytes(t *testing.T) { t.Parallel() // Make sure we don't count the build time as part of the run time. testenv.MustHaveGoBuild(t) ex/ This file contains the implementation of Go select statements. import ( "internal/abi" "internal/runtime/sys" "unsafe" ) const debugSelect = false // Select case descriptor. // Known to compiler. // Changes here must also be made in src/cmd/compile/internal/walk/select.go's scasetype. type scase struct { c *hchan // chan elem unsafe.Pointer // data element } var ( chansendpc = abi.FuncPCABIInternal(chansend) chanrecvpc = abi.FuncPCABIInternal(chanrecv) ) func selectsetpc(pc *uintptr) { *pc = sys.GetCallerP // Start some noise in the background. var wg sync.WaitGroup wg.Add(1) done := make(chan struct{}) go func() { defer wg.Done() for { // Add more things here that could influence metrics. for i := 0; i < len(readMetricsSink); i++ { readMetricsSink[i] = make([]byte, 1024) select { case <-done: return default: } } runtime.GC() } }() sum := func(us []uint64) uint64 { total := uint64(0) for _, u := range us { total += u } return total } // Populate the first generation. moftware is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHingSubmatch(line) n, _ := strconv.Atoi(nStr[1]) frame := &tbFrame{elided: n} cur.frames = append(cur.frames, frame) } } return tbs } // parseTraceback1 is like parseTraceback, but expects tb to contain exactly one // goroutine. func parseTraceback1(t *testing.T, tb string) *traceback { tbs := parseTraceback(t, tb) if len(tbs) != 1 { t.Fatalf("want 1 goroutine, got %d:\n%s", len(tbs), tb) } return tbs[0] } //go:noinline func testTracebackGenericFn[T any](buf []byte) int { return runtime.Stack(buf[:], false) } tring("\tCALL\truntime·callbackasm1(SB)\n") } filename := fmt.Sprintf("zcallback_windows.s") err := os.WriteFile(filename, buf.Bytes(), 0666) if err != nil { fmt.Fprintf(os.Stderr, "wincallback: %s\n", err) os.Exit(2) } } func genasmArm() { var buf bytes.Buffer buf.WriteString(`// Code generated by wincallback.go using 'go generate'. DO NOT EDIT. // External code calls into callbackasm at an offset corresponding // to the callback index. Callbackasm is a table of MOV and B instructions. // The MOV instruction loads ntime·asminit(SB),NOSPLIT,$0-0 RET TEXT runtime·mstart(SB),NOSPLIT|TOPFRAME,$0 JAL runtime·mstart0(SB) RET // not reached /* * go-routine */ // void gogo(Gobuf*) // restore state from Gobuf; longjmp TEXT runtime·gogo(SB),NOSPLIT|NOFRAME,$0-4 MOVW buf+0(FP), R3 MOVW gobuf_g(R3), R4 MOVW 0(R4), R5 // make sure g != nil JMP gogo<>(SB) TEXT gogo<>(SB),NOSPLIT|NOFRAME,$0 MOVW R4, g JAL runtime·save_g(SB) MOVW gobuf_sp(R3), R29 MOVW gobuf_lr(R3), R31 MOVW gobuf_ret(R3), R1 MOVW gobuf_ctxt(R3), REGCTXT MOVW R0, g2 } // sysSigaction calls the sigaction system call. // //go:nosplit func sysSigaction(sig uint32, new, old *sigactiont) { // Use system stack to avoid split stack overflow on amd64 if asmSigaction(uintptr(sig), new, old) != 0 { systemstack(func() { throw("sigaction failed") }) } } // asmSigaction is implemented in assembly. // //go:noescape func asmSigaction(sig uintptr, new, old *sigactiont) int32 // raise sends a signal to the calling thread. // // It must be nosplit because it is used by the signal handler before /ocations } for len(in) > 0 && in[0] != quote { // Process the next character, // rejecting any unescaped newline characters which are invalid. r, multibyte, rem, err := UnquoteChar(in, quote) if in[0] == '\n' || err != nil { return "", in0, ErrSyntax } in = rem // Append the character if unescaping the input. if unescape { if r < utf8.RuneSelf || !multibyte { buf = append(buf, byte(r)) } else { buf = utf8.AppendRune(buf, r) } } // Single quoted strings must be a single catches("", b, n, func(match []int) { if result == nil { result = make([][]int, 0, startSize) } result = append(result, match[0:2]) }) return result } // FindAllString is the 'All' version of [Regexp.FindString]; it returns a slice of all // successive matches of the expression, as defined by the 'All' description // in the package comment. // A return value of nil indicates no match. func (re *Regexp) FindAllString(s string, n int) []string { if n < 0 { n = len(s) + 1 } var result []string re.allMatches(s, nil, n,( "errors" "fmt" "maps" "slices" "strings" "unicode" ) // FormatMediaType serializes mediatype t and the parameters // param as a media type conforming to RFC 2045 and RFC 2616. // The type and parameter names are written in lower-case. // When any of the arguments result in a standard violation then // FormatMediaType returns the empty string. func FormatMediaType(t string, param map[string]string) string { var b strings.Builder if major, sub, ok := strings.Cut(t, "/"); !ok { if !isToken(t) { return "" } b.WriteSNDL R14, CX XORL AX, DX MOVL R13, AX NOTL AX ADDL DX, R8 ANDL R15, AX XORL CX, AX ADDL R8, AX MOVL R9, DI MOVL R11, BX RORL $0x02, DI MOVL R9, DX ANDL R10, BX RORL $0x0d, DX MOVL R9, CX ANDL R11, CX XORL DX, DI XORL CX, BX MOVL R9, DX MOVL R10, CX RORL $0x16, DX ANDL R9, CX XORL CX, BX XORL DX, DI ADDL DI, BX MOVL BX, R8 ADDL AX, R12 ADDL AX, R8 MOVL 152(BP), AX MOVL AX, CX RORL $0x11, AX MOVL CX, DX RORL $0x13, CX SHRL $0x0a, DX Miers. ast.Inspect(f, func(n ast.Node) bool { switch x := n.(type) { case *ast.Ident: if replacement, ok := replacements[x.Name]; ok { x.Name = replacement } } return true }) // Replace identifiers in comments. for _, c := range f.Comments { for _, l := range c.List { for k, v := range replacements { if k == "k" { continue } l.Text = strings.ReplaceAll(l.Text, k, v) } } } out, err := os.Create(*outputFile) if err != nil { log.Fatal(err) } defer out.Close() out.WriteString("marshalBinary(h.ipad); err != nil { panic(err) } return } h.inner.Reset() h.inner.Write(h.ipad) // If the underlying hash is marshalable, we can save some time by saving a // copy of the hash state now, and restoring it on future calls to Reset and // Sum instead of writing ipad/opad every time. // // We do this on Reset to avoid slowing down the common single-use case. // // This is allowed by FIPS 198-1, Section 6: "Conceptually, the intermediate // results of the compression function on the B-byte blocks (K0 le. // Package nistec implements the elliptic curves from NIST SP 800-186. // // This package uses fiat-crypto or specialized assembly and Go code for its // backend field arithmetic (not math/big) and exposes constant-time, heap // allocation-free, byte slice-based safe APIs. Group operations use modern and // safe complete addition formulas where possible. The point at infinity is // handled and encoded according to SEC 1, Version 2.0, and invalid curve points // can't be represented. package nistec import _ "crypto/internal/fifffffff00000000 DATA p256one<>+16(SB)/8, $0xffffffffffffffff DATA p256one<>+24(SB)/8, $0x00000000fffffffe GLOBL p256one<>(SB), RODATA, $32 // func p256IsZero() // Requires: CMOV TEXT p256IsZero(SB), NOSPLIT, $0 // AX contains a flag that is set if the input is zero. XORQ AX, AX MOVQ $0x00000001, R15 // Check whether [acc4..acc7] are all zero. MOVQ R10, R14 ORQ R11, R14 ORQ R12, R14 ORQ R13, R14 // Set the zero flag if so. (CMOV of a constant to a register doesn't // appear to be supported in Go. Thus t1 = 1.) CMOVQ, err } return &request{ name: string(args[0]), args: args[1:], }, nil } func readArgs(reader io.Reader, requiredArgs uint32) ([][]byte, error) { argLengths := make([]uint32, requiredArgs) args := make([][]byte, requiredArgs) for i := range argLengths { if err := binary.Read(reader, binary.LittleEndian, &argLengths[i]); err != nil { return nil, fmt.Errorf("invalid request: failed to read %d-th arg len: %w", i, err) } } for i, length := range argLengths { buf := make([]byte, length) if _, err := io.ReadFulfile. #include "textflag.h" // These functions are no-ops, but you can search for their implementations // to find out whether they are linked into a particular binary. // // Each function consists of a two-byte jump over the next 29-bytes, // then a 5-byte indicator sequence unlikely to occur in real x86 instructions, // then a randomly-chosen 24-byte sequence, and finally a return instruction // (the target of the jump). // // These sequences are known to rsc.io/goversion. #define START \ BYTE $0xEB; BYTE $0x1D; BYTE $0xF4; BRootCertificate.crt", "anyPolicyCACert.crt", "AnyPolicyTest14EE.crt" ], "CRLPath": [ "TrustAnchorRootCRL.crl", "anyPolicyCACRL.crl" ], "ShouldValidate": false, "InitialPolicySet": [ "NIST-test-policy-2" ], "InitialPolicyMappingInhibit": false, "InitialExplicit000  *H  0W1 0 UUS10U Test Certificates 20111'0%UUnknown CRL Entry Extension CA0 100101083000Z 301231083000Z0:= &UnknownAuthorityError{ Cert: c, hintErr: fmt.Errorf("empty"), hintCert: c, } actual := uae.Error() if actual != tt.expected { t.Errorf("#%d: UnknownAuthorityError.Error() response invalid actual: %s expected: %s", i, actual, tt.expected) } }) } } var nameConstraintTests = []struct { constraint, domain string expectError bool shouldMatch bool }{ {"", "anything.com", false, true}, {"example.com", "example.com", false, true}, {"example.com.", "example.com", true, false}, {"sage{ExtKeyUsageServerAuth}, expectedError: "incompatible key usage", }, // An invalid DNS SAN should be detected only at validation time so // that we can process CA certificates in the wild that have invalid SANs. // See https://github.com/golang/go/issues/23995 // #77: an invalid DNS or mail SAN will not be detected if name constraint // checking is not triggered. { roots: make([]constraintsSpec, 1), intermediates: [][]constraintsSpec{ { {}, }, }, leaf: leafSpec{ sans: []string{"dns:this is invali0 bc cf 9c 7d b7 40 20 |.. d8.$:....}.@ | 00000250 01 5f aa d3 16 61 09 a2 76 fd 13 c3 cc e1 0c 5c |._...a..v......\| 00000260 ee b1 87 82 f1 6c 04 ed 73 bb b3 43 77 8d 0c 1c |.....l..s..Cw...| 00000270 f1 0f a1 d8 40 83 61 c9 4c 72 2b 9d ae db 46 06 |....@.a.Lr+...F.| 00000280 06 4d f4 c1 b3 3e c0 d1 bd 42 d4 db fe 3d 13 60 |.M...>...B...=.`| 00000290 84 5c 21 d3 3b e9 fa e7 16 03 01 00 04 0e 00 00 |.\!.;...........| 000002a0 00 |.| >>> Flow 3 (client to server) 00000 000000a0 30 5a 17 0d 32 35 30 31 30 31 30 30 30 30 30 30 |0Z..250101000000| 000000b0 5a 30 1a 31 0b 30 09 06 03 55 04 0a 13 02 47 6f |Z0.1.0...U....Go| 000000c0 31 0b 30 09 06 03 55 04 03 13 02 47 6f 30 81 9f |1.0...U....Go0..| 000000d0 30 0d 06 09 2a 86 48 86 f7 0d 01 01 01 05 00 03 |0...*.H.........| 000000e0 81 8d 00 30 81 89 02 81 81 00 db 46 7d 93 2e 12 |...0.......F}...| 000000f0 27 06 48 bc 06 28 21 ab 7e c4 b6 a2 5d fe 1e 52 |'.H..(!.~...]..R| 00000100 45 88 7a 36 47 a5 08 0d 92 42 5b c2 81 c0 be 97 |E./| 00000030 00 ff 01 00 00 40 00 23 00 00 00 16 00 00 00 17 |.....@.#........| 00000040 00 00 00 0d 00 30 00 2e 04 03 05 03 06 03 08 07 |.....0..........| 00000050 08 08 08 09 08 0a 08 0b 08 04 08 05 08 06 04 01 |................| 00000060 05 01 06 01 03 03 02 03 03 01 02 01 03 02 02 02 |................| 00000070 04 02 05 02 06 02 |......| >>> Flow 2 (server to client) 00000000 16 03 03 00 39 02 00 00 35 03 03 00 00 00 00 00 |....9...5.......| 00000010 00 00 00 00 00 00 00 00 00 0turn ss, nil } if !s.ReadUint64(&ss.useBy) || !s.ReadUint32(&ss.ageAdd) || !s.Empty() { return nil, errors.New("tls: invalid session encoding") } return ss, nil } // sessionState returns a partially filled-out [SessionState] with information // from the current connection. func (c *Conn) sessionState() *SessionState { return &SessionState{ version: c.vers, cipherSuite: c.cipherSuite, createdAt: uint64(c.config.time().Unix()), alpnProtocol: c.clientProtocol, peerCertificates: c.peerCer if bytes.Equal([]byte(opensslReadKeyUpdate), line) { o.readKeyUpdate <- struct{}{} } o.line = next } return len(data), nil } func (o *opensslOutputSink) String() string { return string(o.all) } // clientTest represents a test of the TLS client handshake against a reference // implementation. type clientTest struct { // name is a freeform string identifying the test and the file in which // the expected results will be stored. name string // args, if not empty, contains a series of arguments for the // command t7e, 0x7f, 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89, 0x8a, 0x8b, 0x8c, 0x8d, 0x8e, 0x8f, 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0x9c, 0x9d, 0x9e, 0x9f, 0xa0, 0xa1, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xab, 0xac, 0xad, 0xae, 0xaf, }, []byte{ 0x06, 0xa6, 0xb8, 0x8c, 0x58, 0x53, 0x36, 0x1a, 0x06, 0x10, 0x4c, 0x9c, 0xeb, 0x35, 0xb4, 0x5c, 0xef, 0x76, 0x00, 0x14, 0x90, 0x46, 0x71, 0x01, 0x4a, 0x19, 0x3f, 0x40, 0xc1, 0x5f, 0xc2, 0x44, . The message must be no longer than the // length of the public modulus minus 11 bytes. // // The random parameter is used as a source of entropy to ensure that // encrypting the same message twice doesn't result in the same // ciphertext. Most applications should use [crypto/rand.Reader] // as random. Note that the returned ciphertext does not depend // deterministically on the bytes read from random, and may change // between calls and/or between versions. // // WARNING: use of this function to encrypt plaintexts other than // nction that returns a new instance of the given // hash function. This is intended to be called from the init function in // packages that implement hash functions. func RegisterHash(h Hash, f func() hash.Hash) { if h >= maxHash { panic("crypto: RegisterHash of unknown hash function") } hashes[h] = f } // PublicKey represents a public key using an unspecified algorithm. // // Although this type is an empty interface for backwards compatibility reasons, // all public key types in the standard library implement the following in= 255. It is the reader given to the // LZW decoder, which is thus immune to the blocking. After the LZW decoder // completes, there will be a 0-byte block remaining (0, ()), which is // consumed when checking that the blockReader is exhausted. // // To avoid the allocation of a bufio.Reader for the lzw Reader, blockReader // implements io.ByteReader and buffers blocks into the decoder's "tmp" buffer. type blockReader struct { d *decoder i, j uint8 // d.tmp[i:j] contains the buffered bytes err error } func (b *blockReader) fffffff ffffffffffff } #SNG: from basn3p08.png IHDR { width: 32; height: 32; bitdepth: 8; using color palette; } gAMA {1.0000} PLTE { ( 34, 68, 0) # rgb = (0x22,0x44,0x00) (245,255,237) # rgb = (0xf5,0xff,0xed) (119,255,119) # rgb = (0x77,0xff,0x77) (203,255,255) # rgb = (0xcb,0xff,0xff) ( 17, 10, 0) # rgb = (0x11,0x0a,0x00) ( 58,119, 0) # rgb = (0x3a,0x77,0x00) ( 34, 34,255) # rgb = (0x22,0x22,0xff) (255, 17,255) # rgb = (0xff,0x11,0xff) ( 17, 0, 0) for x := b.Min.X; x < b.Max.X; x++ { _, _, _, a := m.At(x, y).RGBA() if a != 0xffff { return false } } } return true } // The absolute value of a byte interpreted as a signed int8. func abs8(d uint8) int { if d < 128 { return int(d) } return 256 - int(d) } func (e *encoder) writeChunk(b []byte, name string) { if e.err != nil { return } n := uint32(len(b)) if int(n) != len(b) { e.err = UnsupportedError(name + " chunk is too large: " + strconv.Itoa(len(b))) return } binary.BigEndian.PutUint32(e., "}\n") } } else if strings.HasPrefix(filename, "ft") { if s, ok := fakebKGDs[filename]; ok { io.WriteString(w, s) } // We fake a tRNS chunk. The test files' grayscale and truecolor // transparent images all have their top left corner transparent. switch c := png.At(0, 0).(type) { case color.NRGBA: if c.A == 0 { useTransparent = true io.WriteString(w, "tRNS {\n") switch filename { case "ftbbn0g01", "ftbbn0g02", "ftbbn0g04": // The standard image package doesn't have a "gray with // aleturns it directly without searching // for additional extensions. For example, // "C:\foo\example.com" would be returned as-is even if the // program is actually "C:\foo\example.com.exe". func lookExtensions(path, dir string) (string, error) { if filepath.Base(path) == path { path = "." + string(filepath.Separator) + path } exts := pathExt() if ext := filepath.Ext(path); ext != "" { for _, e := range exts { if strings.EqualFold(ext, e) { // Assume that path has already been resolved. return path, nil } } }= nil && dir.IsDir() { return nil } return err } return nil } // RemoveAll removes path and any children it contains. // It removes everything it can but returns the first error // it encounters. If the path does not exist, RemoveAll // returns nil (no error). // If there is an error, it will be of type [*PathError]. func RemoveAll(path string) error { return removeAll(path) } // endsWithDot reports whether the final component of path is ".". func endsWithDot(path string) bool { if path == "." { return true } if le, syscallArgs) return } } func TestCmdArgs(t *testing.T) { if testing.Short() { t.Skipf("in short mode; skipping test that builds a binary") } t.Parallel() tmpdir := t.TempDir() const prog = ` package main import ( "fmt" "os" ) func main() { fmt.Printf("%q", os.Args) } ` src := filepath.Join(tmpdir, "main.go") if err := os.WriteFile(src, []byte(prog), 0666); err != nil { t.Fatal(err) } exe := filepath.Join(tmpdir, "main.exe") cmd := testenv.Command(t, testenv.GoToolPath(t), "build", "-o", exe, src) cmd.Di uint64) int { i := 0 for x >= 0x80 { buf[i] = byte(x) | 0x80 x >>= 7 i++ } buf[i] = byte(x) return i + 1 } // Uvarint decodes a uint64 from buf and returns that value and the // number of bytes read (> 0). If an error occurred, the value is 0 // and the number of bytes n is <= 0 meaning: // - n == 0: buf too small; // - n < 0: value larger than 64 bits (overflow) and -n is the number of // bytes read. func Uvarint(buf []byte) (uint64, int) { var x uint64 var s uint for i, b := range buf { if i == MaxVarint '-' { d.buf.WriteByte(b) } else { d.ungetc(b) break } } return d.buf.Bytes() } // Skip spaces if any func (d *Decoder) space() { for { b, ok := d.getc() if !ok { return } switch b { case ' ', '\r', '\n', '\t': default: d.ungetc(b) return } } } // Read a single byte. // If there is no byte to read, return ok==false // and leave the error in d.err. // Maintain line number. func (d *Decoder) getc() (b byte, ok bool) { if d.err != nil { return 0, false } if d.nextByte >= 0 { b = byte(d.beds a pointer to an unexported type, // it is not possible to set a newly allocated value // since the field is unexported. // // See https://golang.org/issue/21357 if !subv.CanSet() { d.saveError(fmt.Errorf("json: cannot set embedded pointer to unexported struct: %v", subv.Type().Elem())) // Invalidate subv to ensure d.value(subv) skips over // the JSON value without assigning it to subv. subv = reflect.Value{} destring = false break } 04, 0x15, 0x30, 0x13, 0x81, 0x11, 0x67, 0x65, 0x6e, 0x65, 0x72, 0x61, 0x6c, 0x40, 0x69, 0x70, 0x73, 0x63, 0x61, 0x2e, 0x63, 0x6f, 0x6d, 0x30, 0x72, 0x06, 0x09, 0x60, 0x86, 0x48, 0x01, 0x86, 0xf8, 0x42, 0x01, 0x0d, 0x04, 0x65, 0x16, 0x63, 0x4f, 0x72, 0x67, 0x61, 0x6e, 0x69, 0x7a, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x49, 0x6e, 0x66, 0x6f, 0x72, 0x6d, 0x61, 0x74, 0x69, 0x6f, 0x6e, 0x20, 0x4e, 0x4f, 0x54, 0x20, 0x56, 0x41, 0x4c, 0x49, 0x44, 0x41, 0x54, 0x45, 0x44, 0x2e, 0x20, 0x43, 0x4c, 0x41, 0x53, 0x45, 0x41, 0x31, 0x20, 0x53t.Error(err) } const want = "decoding dwarf section info" _, err = nf.DWARF() if err == nil || !strings.Contains(err.Error(), want) { t.Errorf("DWARF = %v; want %q", err, want) } } func BenchmarkSymbols64(b *testing.B) { const testdata = "testdata/gcc-amd64-linux-exec" f, err := Open(testdata) if err != nil { b.Fatalf("could not read %s: %v", testdata, err) } defer f.Close() b.ResetTimer() for i := 0; i < b.N; i++ { symbols, err := f.Symbols() if err != nil { b.Fatalf("Symbols(): got unexpected error %v", e = 0x20000000 IMAGE_SCN_MEM_READ = 0x40000000 IMAGE_SCN_MEM_WRITE = 0x80000000 ) // Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package pe import ( "bytes" "debug/dwarf" "internal/testenv" "os" "os/exec" "path/filepath" "reflect" "regexp" "runtime" "strconv" "testing" "text/template" ) type fileTest struct { file string hdr FileHeader opthdr any aks the rules of that format, // or when there are I/O errors reading the file. var errUnrecognizedFormat = errors.New("unrecognized file format") // errNotGoExe is returned when a given executable file is valid but does // not contain Go build information. // // errNotGoExe should be an internal detail, // but widely used packages access it using linkname. // Notable members of the hall of shame include: // - github.com/quay/claircore // // Do not remove or change the type signature. // See go.dev/issue/67401. // //go:linkname tBuffered: 0, }, { name: "discard negative", r: newScriptedReader(), // will panic on Read n: -1, want: 0, wantErr: ErrNegativeCount, wantBuffered: 0, }, } for _, tt := range tests { br := NewReaderSize(tt.r, tt.bufSize) if tt.peekSize > 0 { peekBuf, err := br.Peek(tt.peekSize) if err != nil { t.Errorf("%s: Peek(%d): %v", tt.name, tt.peekSize, err) continue } if len(peekBuf) != tt.peekSize { t.Errorf("%s: len(Peek(%d)) = %v; want %v", tror must be returned. // // This must also check opts.ReadOnly to determine if the read-only // value is true to either set the read-only transaction property if supported // or return an error if it is not supported. BeginTx(ctx context.Context, opts TxOptions) (Tx, error) } // SessionResetter may be implemented by [Conn] to allow drivers to reset the // session state associated with the connection and to signal a bad connection. type SessionResetter interface { // ResetSession is called prior to executing a query on the coRza/b/cUT7}`ux ES_PKUEsDBBQACAAAAGWHaECoZTJ+BAAAAAQAAAAHABgAZm9vLnR4dFVUBQAD3lVZT3V4CwABBPUBAAAEFAAAAGZvbwqoZTJ+BAAAAAQAAABQSwMEFAAIAAAAZodoQOmzogQEAAAABAAAAAcAGABiYXIudHh0VVQFAAPgVVlPdXgLAAEE9QEAAAQUAAAAYmFyCumzogQEAAAABAAAAFBLAQIUAxQACAAAAGWHaECoZTJ+BAAAAAQAAAAHABgAAAAAAAAAAACkgQAAAABmb28udHh0VVQFAAPeVVlPdXgLAAEE9QEAAAQUAAAAUEsBAhQDFAAIAAAAZodoQOmzogQEAAAABAAAAAcAGAAAAAAAAAAAAKSBTQAAAGJhci50eHRVVAUAA+BVWU91eAsAAQT1AQAABBQAAABQSwUGAAAAAAIAAgCaAAAAmgAAAAAA PKMinor() []byte { return h[337:][:8] } func (h *headerUSTAR) prefix() []byte { return h[345:][:155] } type sparseArray []byte func (s sparseArray) entry(i int) sparseElem { return sparseElem(s[i*24:]) } func (s sparseArray) isExtended() []byte { return s[24*s.maxEntries():][:1] } func (s sparseArray) maxEntries() int { return len(s) / 24 } type sparseElem []byte func (s sparseElem) offset() []byte { return s[00:][:12] } func (s sparseElem) length() []byte { return s[12:][:12] } ./PaxHeaders.29205/small.txt, err := time.LoadLocation(locName) if err != nil { t.Fatal(err) } d := time.Date(1900, time.January, 1, 0, 0, 0, 0, loc) tzName, tzOffset := d.Zone() if want := "EST"; tzName != want { t.Errorf("Zone name == %s, want %s", tzName, want) } if want := -18000; tzOffset != want { t.Errorf("Zone offset == %d, want %d", tzOffset, want) } } func TestMalformedTZData(t *testing.T) { // The goal here is just that malformed tzdata results in an error, not a panic. issue29437 := "TZif\x00000000000000000\x00\x00\x00\x01\x00\x0ize) } } // Since each Write is fully gated, if multiple Read calls were needed, // the contents of Write should still appear together in the output. got := string(buf) want := strings.Repeat(input, count) if got != want { t.Errorf("got: %q; want: %q", got, want) } }) t.Run("Read", func(t *testing.T) { r, w := Pipe() c := make(chan []byte, count*len(input)/readSize) for i := 0; i < cap(c); i++ { go func() { time.Sleep(time.Millisecond) // Increase probability of race buf := make([]byte, reaTypeFunction, TypeObject: return true default: panic("bad type") } } // String returns the value v as a string. // String is a special case because of Go's String method convention. Unlike the other getters, // it does not panic if v's Type is not TypeString. Instead, it returns a string of the form "" // or "" where T is v's type and V is a string representation of v's value. func (v Value) String() string { switch v.Type() { case TypeString: return jsString(v) case TypeUndefined: return "" case DLL Name string addr uintptr } // Addr returns the address of the procedure represented by p. // The return value can be passed to Syscall to run the procedure. func (p *Proc) Addr() uintptr { return p.addr } // Call executes procedure p with arguments a. // // The returned error is always non-nil, constructed from the result of GetLastError. // Callers must inspect the primary return value to decide whether an error occurred // (according to the semantics of the specific function being called) before consulting // the error. s first occurrence in envs. env map[string]int // envs is provided by the runtime. elements are expected to // be of the form "key=value". An empty string means deleted // (or a duplicate to be ignored). envs []string = runtime_envs() ) func runtime_envs() []string // in package runtime func copyenv() { env = make(map[string]int) for i, s := range envs { for j := 0; j < len(s); j++ { if s[j] == '=' { key := s[:j] if _, ok := env[key]; !ok { env[key] = i // first mention of key } else { // Clear the buffer is small enough that the loop // below will need to execute multiple times. See issue #31368. size := N * unsafe.Offsetof(syscall.Dirent{}.Name) / 4 if runtime.GOOS == "freebsd" || runtime.GOOS == "netbsd" { if size < 1024 { size = 1024 // DIRBLKSIZ, see issue 31403. } } // Make a directory containing N files d := t.TempDir() var files []string for i := 0; i < N; i++ { files = append(files, fmt.Sprintf("file%d", i)) } for _, file := range files { err := os.WriteFile(filepath.Join(d, file), []byte("yUsers := []string{"nobody"} if testenv.Builder() != "" { tryUsers = append(tryUsers, "gopher") } for _, name := range tryUsers { u, err = user.Lookup(name) if err == nil { break } fmt.Fprintf(os.Stderr, "Lookup(%q): %v\n", name, err) } } if u == nil { // If we couldn't find an unprivileged user to run as, try running as // the current user. (Empirically this still causes the call to Start to // fail with a permission error if running as a non-root user on Linux.) u, err = user.Current() if er:build unix package syscall_test import ( "flag" "fmt" "internal/testenv" "io" "net" "os" "os/exec" "path/filepath" "runtime" "strconv" "syscall" "testing" "time" ) // Tests that below functions, structures and constants are consistent // on all Unix-like systems. func _() { // program scheduling priority functions and constants var ( _ func(int, int, int) error = syscall.Setpriority _ func(int, int) (int, error) = syscall.Getpriority ) const ( _ int = syscall.PRIO_USER _ int = syscall.PRIO_PROCESS _ // func Syscall9(trap int64, a1, a2, a3, a4, a5, a6, a7, a8, a9 int64) (r1, r2, err int64); TEXT ·Syscall9(SB),NOSPLIT,$32-104 NO_LOCAL_POINTERS CALL runtime·entersyscall(SB) MOVQ num+0(FP), AX // syscall entry MOVQ a1+8(FP), DI MOVQ a2+16(FP), SI MOVQ a3+24(FP), DX MOVQ a4+32(FP), R10 MOVQ a5+40(FP), R8 MOVQ a6+48(FP), R9 MOVQ a7+56(FP), R11 MOVQ a8+64(FP), R12 MOVQ a9+72(FP), R13 // only the first 6 arguments can be passed in registers, // the last three should be placed at the top of the stack. MNSPEC = 0x0 IFLA_ADDRESS = 0x1 IFLA_BROADCAST = 0x2 IFLA_IFNAME = 0x3 IFLA_MTU = 0x4 IFLA_LINK = 0x5 IFLA_QDISC = 0x6 IFLA_STATS = 0x7 IFLA_COST = 0x8 IFLA_PRIORITY = 0x9 IFLA_MASTER = 0xa IFLA_WIRELESS = 0xb IFLA_PROTINFO = 0xc IFLA_TXQLEN = 0xd IFLA_MAP = 0xe IFLA_WEIGHT = 0xf IFLA_OPERSTATE = 0x10 IFLA_LINKMODE = 0x11 IFLA_LINKINFO = 0x12 IFLA_NET_NS_PID = 0x13 ring, mode uint32) (fd int, err error) { return Open(path, O_CREAT|O_WRONLY|O_TRUNC, mode) } func EpollCreate(size int) (fd int, err error) { if size <= 0 { return -1, EINVAL } return EpollCreate1(0) } func isGroupMember(gid int) bool { groups, err := Getgroups() if err != nil { return false } for _, g := range groups { if g == gid { return true } } return false } func isCapDacOverrideSet() bool { const _CAP_DAC_OVERRIDE = 1 var c caps c.hdr.version = _LINUX_CAPABILITY_VERSION_3 _, _, err := RawSyscall() { if err := fn(); err != nil { t.Fatalf("%s: %v", name, err) } })) if n > 0 { t.Errorf("allocs = %d, want 0", n) } }) } testAllocs(t, "SyscallN", func() error { r0, _, e1 := syscall.SyscallN(proc, 0, 0, 0) if r0 == 0 { return syscall.Errno(e1) } return nil }) testAllocs(t, "Syscall", func() error { r0, _, e1 := syscall.Syscall(proc, 3, 0, 0, 0) if r0 == 0 { return syscall.Errno(e1) } return nil }) } func FuzzUTF16FromString(f *testing.F) { f.Add("hi") // ASCII return bb, nil } // readdirnames returns the names of files inside the directory represented by dirfd. func readdirnames(dirfd int) (names []string, err error) { names = make([]string, 0, 100) var buf [STATMAX]byte for { n, e := Read(dirfd, buf[:]) if e != nil { return nil, e } if n == 0 { break } for b := buf[:n]; len(b) > 0; { var s []byte s, b = gdirname(b) if s == nil { return nil, ErrBadStat } names = append(names, string(s)) } } return } // name of the directory containing names [0]) } else { _p0 = unsafe.Pointer(&_zero) } r0, _, e1 := Syscall(SYS_FWSTAT, uintptr(fd), uintptr(_p0), uintptr(len(edir))) if int32(r0) == -1 { err = e1 } return } // mksysnum_openbsd.pl // Code generated by the command above; DO NOT EDIT. package syscall const ( SYS_EXIT = 1 // { void sys_exit(int rval); } SYS_FORK = 2 // { int sys_fork(void); } SYS_READ = 3 // { ssize_t sys_read(int fd, void *buf, size_t nbyte); } SYS_WRITE = 4 // { ssize_t sys_write(int fd, const verr := cmd.CombinedOutput() if len(out) > 0 { t.Logf("%s", out) } if err != nil { t.Fatalf("subprocess failed: %v", err) } s := string(bytes.TrimSpace(out)) v, err := strconv.ParseUint(s, 10, 64) if err != nil { t.Fatalf("could not parse %q as number: %v", s, v) } if v != uint64(orig.Cur) { t.Errorf("exec rlimit = %d, want %d", v, orig) } } func TestForkExecNilArgv(t *testing.T) { defer func() { if p := recover(); p != nil { t.Fatal("forkExec panicked") } }() // We don't really care what the result ofUse golang.org/x/net/route instead. type InterfaceAddrMessage struct { Header IfaMsghdr Data []byte } func (m *InterfaceAddrMessage) sockaddr() ([]Sockaddr, error) { var sas [RTAX_MAX]Sockaddr b := m.Data[:] family := uint8(AF_UNSPEC) for i := uint(0); i < RTAX_MAX && len(b) >= minRoutingSockaddrLen; i++ { if m.Header.Addrs&(1< 0 { _p0 = unsafe := Syscall6(SYS___SYSCTL, uintptr(_p0), uintptr(len(mib)), uintptr(unsafe.Pointer(old)), uintptr(unsafe.Pointer(oldlen)), uintptr(unsafe.Pointer(new)), uintptr(newlen)) if e1 != 0 { err = errnoErr(e1) } return } // Copyright 2023 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 fi