File Manager

✏️ /

// 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 file.

//go:build !goexperiment.allocheaders

// Garbage collector: type and heap bitmaps.
//
// Stack, data, and bss bitmaps
//
// Stack frames and global variables in the data and bss sections are
// described by bitmaps with 1 bit per pointer-sized word. A "1" bit
// means the word is a live pointer to be visited by the GC (referred to
// as "pointer"). A "0" bit means the word should be ignored by GC
// (referred to as "scalar", though it could be a dead pointer value).
//
// Heap bitmap
//
// The heap bitmap comprises 1 bit for each pointer-sized word in the heap,
// recording whether a pointer is stored in that word or not. This bitmap
// is stored in the heapArena metadata backing each heap arena.
// That is, if ha is the heapArena for the arena starting at "start",
// then ha.bitmap[0] holds the 64 bits for the 64 words "start"
// through start+63*ptrSize, ha.bitmap[1] holds the entries for
// start+64*ptrSize through start+127*ptrSize, and so on.
// Bits correspond to words in little-endian order. ha.bitmap[0]&1 represents
// the word at "start", ha.bitmap[0]>>1&1 represents the word at start+8, etc.
// (For 32-bit platforms, s/64/32/.)
//
// We also keep a noMorePtrs bitmap which allows us to stop scanning
// the heap bitmap early in certain situations. If ha.noMorePtrs[i]>>j&1
// is 1, then the object containing the last word described by ha.bitmap[8*i+j]
// has no more pointers beyond those described by ha.bitmap[8*i+j].
// If ha.noMorePtrs[i]>>j&1 is set, the entries in ha.bitmap[8*i+j+1] and
// beyond must all be zero until the start of the next object.
//
// The bitmap for noscan spans is set to all zero at span allocation time.
//
// The bitmap for unallocated objects in scannable spans is not maintained
// (can be junk).

package runtime

import (
	"internal/abi"
	"internal/goarch"
	"runtime/internal/sys"
	"unsafe"
)

const (
	// For compatibility with the allocheaders GOEXPERIMENT.
	mallocHeaderSize       = 0
	minSizeForMallocHeader = ^uintptr(0)
)

// For compatibility with the allocheaders GOEXPERIMENT.
//
//go:nosplit
func heapBitsInSpan(_ uintptr) bool {
	return false
}

// heapArenaPtrScalar contains the per-heapArena pointer/scalar metadata for the GC.
type heapArenaPtrScalar struct {
	// bitmap stores the pointer/scalar bitmap for the words in
	// this arena. See mbitmap.go for a description.
	// This array uses 1 bit per word of heap, or 1.6% of the heap size (for 64-bit).
	bitmap [heapArenaBitmapWords]uintptr

// If the ith bit of noMorePtrs is true, then there are no more
	// pointers for the object containing the word described by the
	// high bit of bitmap[i].
	// In that case, bitmap[i+1], ... must be zero until the start
	// of the next object.
	// We never operate on these entries using bit-parallel techniques,
	// so it is ok if they are small. Also, they can't be bigger than
	// uint16 because at that size a single noMorePtrs entry
	// represents 8K of memory, the minimum size of a span. Any larger
	// and we'd have to worry about concurrent updates.
	// This array uses 1 bit per word of bitmap, or .024% of the heap size (for 64-bit).
	noMorePtrs [heapArenaBitmapWords / 8]uint8
}

// heapBits provides access to the bitmap bits for a single heap word.
// The methods on heapBits take value receivers so that the compiler
// can more easily inline calls to those methods and registerize the
// struct fields independently.
type heapBits struct {
	// heapBits will report on pointers in the range [addr,addr+size).
	// The low bit of mask contains the pointerness of the word at addr
	// (assuming valid>0).
	addr, size uintptr

// The next few pointer bits representing words starting at addr.
	// Those bits already returned by next() are zeroed.
	mask uintptr
	// Number of bits in mask that are valid. mask is always less than 1<<valid.
	valid uintptr
}

// heapBitsForAddr returns the heapBits for the address addr.
// The caller must ensure [addr,addr+size) is in an allocated span.
// In particular, be careful not to point past the end of an object.
//
// nosplit because it is used during write barriers and must not be preempted.
//
//go:nosplit
func heapBitsForAddr(addr, size uintptr) heapBits {
	// Find arena
	ai := arenaIndex(addr)
	ha := mheap_.arenas[ai.l1()][ai.l2()]

// Word index in arena.
	word := addr / goarch.PtrSize % heapArenaWords

// Word index and bit offset in bitmap array.
	idx := word / ptrBits
	off := word % ptrBits

// Grab relevant bits of bitmap.
	mask := ha.bitmap[idx] >> off
	valid := ptrBits - off

// Process depending on where the object ends.
	nptr := size / goarch.PtrSize
	if nptr < valid {
		// Bits for this object end before the end of this bitmap word.
		// Squash bits for the following objects.
		mask &= 1<<(nptr&(ptrBits-1)) - 1
		valid = nptr
	} else if nptr == valid {
		// Bits for this object end at exactly the end of this bitmap word.
		// All good.
	} else {
		// Bits for this object extend into the next bitmap word. See if there
		// may be any pointers recorded there.
		if uintptr(ha.noMorePtrs[idx/8])>>(idx%8)&1 != 0 {
			// No more pointers in this object after this bitmap word.
			// Update size so we know not to look there.
			size = valid * goarch.PtrSize
		}
	}

return heapBits{addr: addr, size: size, mask: mask, valid: valid}
}

// Returns the (absolute) address of the next known pointer and
// a heapBits iterator representing any remaining pointers.
// If there are no more pointers, returns address 0.
// Note that next does not modify h. The caller must record the result.
//
// nosplit because it is used during write barriers and must not be preempted.
//
//go:nosplit
func (h heapBits) next() (heapBits, uintptr) {
	for {
		if h.mask != 0 {
			var i int
			if goarch.PtrSize == 8 {
				i = sys.TrailingZeros64(uint64(h.mask))
			} else {
				i = sys.TrailingZeros32(uint32(h.mask))
			}
			h.mask ^= uintptr(1) << (i & (ptrBits - 1))
			return h, h.addr + uintptr(i)*goarch.PtrSize
		}

// Skip words that we've already processed.
		h.addr += h.valid * goarch.PtrSize
		h.size -= h.valid * goarch.PtrSize
		if h.size == 0 {
			return h, 0 // no more pointers
		}

// Grab more bits and try again.
		h = heapBitsForAddr(h.addr, h.size)
	}
}

// nextFast is like next, but can return 0 even when there are more pointers
// to be found. Callers should call next if nextFast returns 0 as its second
// return value.
//
//	if addr, h = h.nextFast(); addr == 0 {
//	    if addr, h = h.next(); addr == 0 {
//	        ... no more pointers ...
//	    }
//	}
//	... process pointer at addr ...
//
// nextFast is designed to be inlineable.
//
//go:nosplit
func (h heapBits) nextFast() (heapBits, uintptr) {
	// TESTQ/JEQ
	if h.mask == 0 {
		return h, 0
	}
	// BSFQ
	var i int
	if goarch.PtrSize == 8 {
		i = sys.TrailingZeros64(uint64(h.mask))
	} else {
		i = sys.TrailingZeros32(uint32(h.mask))
	}
	// BTCQ
	h.mask ^= uintptr(1) << (i & (ptrBits - 1))
	// LEAQ (XX)(XX*8)
	return h, h.addr + uintptr(i)*goarch.PtrSize
}

// bulkBarrierPreWrite executes a write barrier
// for every pointer slot in the memory range [src, src+size),
// using pointer/scalar information from [dst, dst+size).
// This executes the write barriers necessary before a memmove.
// src, dst, and size must be pointer-aligned.
// The range [dst, dst+size) must lie within a single object.
// It does not perform the actual writes.
//
// As a special case, src == 0 indicates that this is being used for a
// memclr. bulkBarrierPreWrite will pass 0 for the src of each write
// barrier.
//
// Callers should call bulkBarrierPreWrite immediately before
// calling memmove(dst, src, size). This function is marked nosplit
// to avoid being preempted; the GC must not stop the goroutine
// between the memmove and the execution of the barriers.
// The caller is also responsible for cgo pointer checks if this
// may be writing Go pointers into non-Go memory.
//
// The pointer bitmap is not maintained for allocations containing
// no pointers at all; any caller of bulkBarrierPreWrite must first
// make sure the underlying allocation contains pointers, usually
// by checking typ.PtrBytes.
//
// The type of the space can be provided purely as an optimization,
// however it is not used with GOEXPERIMENT=noallocheaders.
//
// Callers must perform cgo checks if goexperiment.CgoCheck2.
//
//go:nosplit
func bulkBarrierPreWrite(dst, src, size uintptr, _ *abi.Type) {
	if (dst|src|size)&(goarch.PtrSize-1) != 0 {
		throw("bulkBarrierPreWrite: unaligned arguments")
	}
	if !writeBarrier.enabled {
		return
	}
	if s := spanOf(dst); s == nil {
		// If dst is a global, use the data or BSS bitmaps to
		// execute write barriers.
		for _, datap := range activeModules() {
			if datap.data <= dst && dst < datap.edata {
				bulkBarrierBitmap(dst, src, size, dst-datap.data, datap.gcdatamask.bytedata)
				return
			}
		}
		for _, datap := range activeModules() {
			if datap.bss <= dst && dst < datap.ebss {
				bulkBarrierBitmap(dst, src, size, dst-datap.bss, datap.gcbssmask.bytedata)
				return
			}
		}
		return
	} else if s.state.get() != mSpanInUse || dst < s.base() || s.limit <= dst {
		// dst was heap memory at some point, but isn't now.
		// It can't be a global. It must be either our stack,
		// or in the case of direct channel sends, it could be
		// another stack. Either way, no need for barriers.
		// This will also catch if dst is in a freed span,
		// though that should never have.
		return
	}

buf := &getg().m.p.ptr().wbBuf
	h := heapBitsForAddr(dst, size)
	if src == 0 {
		for {
			var addr uintptr
			if h, addr = h.next(); addr == 0 {
				break
			}
			dstx := (*uintptr)(unsafe.Pointer(addr))
			p := buf.get1()
			p[0] = *dstx
		}
	} else {
		for {
			var addr uintptr
			if h, addr = h.next(); addr == 0 {
				break
			}
			dstx := (*uintptr)(unsafe.Pointer(addr))
			srcx := (*uintptr)(unsafe.Pointer(src + (addr - dst)))
			p := buf.get2()
			p[0] = *dstx
			p[1] = *srcx
		}
	}
}

// bulkBarrierPreWriteSrcOnly is like bulkBarrierPreWrite but
// does not execute write barriers for [dst, dst+size).
//
// In addition to the requirements of bulkBarrierPreWrite
// callers need to ensure [dst, dst+size) is zeroed.
//
// This is used for special cases where e.g. dst was just
// created and zeroed with malloc.
//
// The type of the space can be provided purely as an optimization,
// however it is not used with GOEXPERIMENT=noallocheaders.
//
//go:nosplit
func bulkBarrierPreWriteSrcOnly(dst, src, size uintptr, _ *abi.Type) {
	if (dst|src|size)&(goarch.PtrSize-1) != 0 {
		throw("bulkBarrierPreWrite: unaligned arguments")
	}
	if !writeBarrier.enabled {
		return
	}
	buf := &getg().m.p.ptr().wbBuf
	h := heapBitsForAddr(dst, size)
	for {
		var addr uintptr
		if h, addr = h.next(); addr == 0 {
			break
		}
		srcx := (*uintptr)(unsafe.Pointer(addr - dst + src))
		p := buf.get1()
		p[0] = *srcx
	}
}

// initHeapBits initializes the heap bitmap for a span.
// If this is a span of single pointer allocations, it initializes all
// words to pointer. If force is true, clears all bits.
func (s *mspan) initHeapBits(forceClear bool) {
	if forceClear || s.spanclass.noscan() {
		// Set all the pointer bits to zero. We do this once
		// when the span is allocated so we don't have to do it
		// for each object allocation.
		base := s.base()
		size := s.npages * pageSize
		h := writeHeapBitsForAddr(base)
		h.flush(base, size)
		return
	}
	isPtrs := goarch.PtrSize == 8 && s.elemsize == goarch.PtrSize
	if !isPtrs {
		return // nothing to do
	}
	h := writeHeapBitsForAddr(s.base())
	size := s.npages * pageSize
	nptrs := size / goarch.PtrSize
	for i := uintptr(0); i < nptrs; i += ptrBits {
		h = h.write(^uintptr(0), ptrBits)
	}
	h.flush(s.base(), size)
}

type writeHeapBits struct {
	addr  uintptr // address that the low bit of mask represents the pointer state of.
	mask  uintptr // some pointer bits starting at the address addr.
	valid uintptr // number of bits in buf that are valid (including low)
	low   uintptr // number of low-order bits to not overwrite
}

func writeHeapBitsForAddr(addr uintptr) (h writeHeapBits) {
	// We start writing bits maybe in the middle of a heap bitmap word.
	// Remember how many bits into the word we started, so we can be sure
	// not to overwrite the previous bits.
	h.low = addr / goarch.PtrSize % ptrBits

// round down to heap word that starts the bitmap word.
	h.addr = addr - h.low*goarch.PtrSize

// We don't have any bits yet.
	h.mask = 0
	h.valid = h.low

return
}

// write appends the pointerness of the next valid pointer slots
// using the low valid bits of bits. 1=pointer, 0=scalar.
func (h writeHeapBits) write(bits, valid uintptr) writeHeapBits {
	if h.valid+valid <= ptrBits {
		// Fast path - just accumulate the bits.
		h.mask |= bits << h.valid
		h.valid += valid
		return h
	}
	// Too many bits to fit in this word. Write the current word
	// out and move on to the next word.

data := h.mask | bits<<h.valid       // mask for this word
	h.mask = bits >> (ptrBits - h.valid) // leftover for next word
	h.valid += valid - ptrBits           // have h.valid+valid bits, writing ptrBits of them

// Flush mask to the memory bitmap.
	// TODO: figure out how to cache arena lookup.
	ai := arenaIndex(h.addr)
	ha := mheap_.arenas[ai.l1()][ai.l2()]
	idx := h.addr / (ptrBits * goarch.PtrSize) % heapArenaBitmapWords
	m := uintptr(1)<<h.low - 1
	ha.bitmap[idx] = ha.bitmap[idx]&m | data
	// Note: no synchronization required for this write because
	// the allocator has exclusive access to the page, and the bitmap
	// entries are all for a single page. Also, visibility of these
	// writes is guaranteed by the publication barrier in mallocgc.

// Clear noMorePtrs bit, since we're going to be writing bits
	// into the following word.
	ha.noMorePtrs[idx/8] &^= uint8(1) << (idx % 8)
	// Note: same as above

// Move to next word of bitmap.
	h.addr += ptrBits * goarch.PtrSize
	h.low = 0
	return h
}

// Add padding of size bytes.
func (h writeHeapBits) pad(size uintptr) writeHeapBits {
	if size == 0 {
		return h
	}
	words := size / goarch.PtrSize
	for words > ptrBits {
		h = h.write(0, ptrBits)
		words -= ptrBits
	}
	return h.write(0, words)
}

// Flush the bits that have been written, and add zeros as needed
// to cover the full object [addr, addr+size).
func (h writeHeapBits) flush(addr, size uintptr) {
	// zeros counts the number of bits needed to represent the object minus the
	// number of bits we've already written. This is the number of 0 bits
	// that need to be added.
	zeros := (addr+size-h.addr)/goarch.PtrSize - h.valid

// Add zero bits up to the bitmap word boundary
	if zeros > 0 {
		z := ptrBits - h.valid
		if z > zeros {
			z = zeros
		}
		h.valid += z
		zeros -= z
	}

// Find word in bitmap that we're going to write.
	ai := arenaIndex(h.addr)
	ha := mheap_.arenas[ai.l1()][ai.l2()]
	idx := h.addr / (ptrBits * goarch.PtrSize) % heapArenaBitmapWords

// Write remaining bits.
	if h.valid != h.low {
		m := uintptr(1)<<h.low - 1      // don't clear existing bits below "low"
		m |= ^(uintptr(1)<<h.valid - 1) // don't clear existing bits above "valid"
		ha.bitmap[idx] = ha.bitmap[idx]&m | h.mask
	}
	if zeros == 0 {
		return
	}

// Record in the noMorePtrs map that there won't be any more 1 bits,
	// so readers can stop early.
	ha.noMorePtrs[idx/8] |= uint8(1) << (idx % 8)

// Advance to next bitmap word.
	h.addr += ptrBits * goarch.PtrSize

// Continue on writing zeros for the rest of the object.
	// For standard use of the ptr bits this is not required, as
	// the bits are read from the beginning of the object. Some uses,
	// like noscan spans, oblets, bulk write barriers, and cgocheck, might
	// start mid-object, so these writes are still required.
	for {
		// Write zero bits.
		ai := arenaIndex(h.addr)
		ha := mheap_.arenas[ai.l1()][ai.l2()]
		idx := h.addr / (ptrBits * goarch.PtrSize) % heapArenaBitmapWords
		if zeros < ptrBits {
			ha.bitmap[idx] &^= uintptr(1)<<zeros - 1
			break
		} else if zeros == ptrBits {
			ha.bitmap[idx] = 0
			break
		} else {
			ha.bitmap[idx] = 0
			zeros -= ptrBits
		}
		ha.noMorePtrs[idx/8] |= uint8(1) << (idx % 8)
		h.addr += ptrBits * goarch.PtrSize
	}
}

// heapBitsSetType records that the new allocation [x, x+size)
// holds in [x, x+dataSize) one or more values of type typ.
// (The number of values is given by dataSize / typ.Size.)
// If dataSize < size, the fragment [x+dataSize, x+size) is
// recorded as non-pointer data.
// It is known that the type has pointers somewhere;
// malloc does not call heapBitsSetType when there are no pointers,
// because all free objects are marked as noscan during
// heapBitsSweepSpan.
//
// There can only be one allocation from a given span active at a time,
// and the bitmap for a span always falls on word boundaries,
// so there are no write-write races for access to the heap bitmap.
// Hence, heapBitsSetType can access the bitmap without atomics.
//
// There can be read-write races between heapBitsSetType and things
// that read the heap bitmap like scanobject. However, since
// heapBitsSetType is only used for objects that have not yet been
// made reachable, readers will ignore bits being modified by this
// function. This does mean this function cannot transiently modify
// bits that belong to neighboring objects. Also, on weakly-ordered
// machines, callers must execute a store/store (publication) barrier
// between calling this function and making the object reachable.
func heapBitsSetType(x, size, dataSize uintptr, typ *_type) {
	const doubleCheck = false // slow but helpful; enable to test modifications to this code

if doubleCheck && dataSize%typ.Size_ != 0 {
		throw("heapBitsSetType: dataSize not a multiple of typ.Size")
	}

if goarch.PtrSize == 8 && size == goarch.PtrSize {
		// It's one word and it has pointers, it must be a pointer.
		// Since all allocated one-word objects are pointers
		// (non-pointers are aggregated into tinySize allocations),
		// (*mspan).initHeapBits sets the pointer bits for us.
		// Nothing to do here.
		if doubleCheck {
			h, addr := heapBitsForAddr(x, size).next()
			if addr != x {
				throw("heapBitsSetType: pointer bit missing")
			}
			_, addr = h.next()
			if addr != 0 {
				throw("heapBitsSetType: second pointer bit found")
			}
		}
		return
	}

h := writeHeapBitsForAddr(x)

// Handle GC program.
	if typ.Kind_&kindGCProg != 0 {
		// Expand the gc program into the storage we're going to use for the actual object.
		obj := (*uint8)(unsafe.Pointer(x))
		n := runGCProg(addb(typ.GCData, 4), obj)
		// Use the expanded program to set the heap bits.
		for i := uintptr(0); true; i += typ.Size_ {
			// Copy expanded program to heap bitmap.
			p := obj
			j := n
			for j > 8 {
				h = h.write(uintptr(*p), 8)
				p = add1(p)
				j -= 8
			}
			h = h.write(uintptr(*p), j)

if i+typ.Size_ == dataSize {
				break // no padding after last element
			}

// Pad with zeros to the start of the next element.
			h = h.pad(typ.Size_ - n*goarch.PtrSize)
		}

h.flush(x, size)

// Erase the expanded GC program.
		memclrNoHeapPointers(unsafe.Pointer(obj), (n+7)/8)
		return
	}

// Note about sizes:
	//
	// typ.Size is the number of words in the object,
	// and typ.PtrBytes is the number of words in the prefix
	// of the object that contains pointers. That is, the final
	// typ.Size - typ.PtrBytes words contain no pointers.
	// This allows optimization of a common pattern where
	// an object has a small header followed by a large scalar
	// buffer. If we know the pointers are over, we don't have
	// to scan the buffer's heap bitmap at all.
	// The 1-bit ptrmasks are sized to contain only bits for
	// the typ.PtrBytes prefix, zero padded out to a full byte
	// of bitmap. If there is more room in the allocated object,
	// that space is pointerless. The noMorePtrs bitmap will prevent
	// scanning large pointerless tails of an object.
	//
	// Replicated copies are not as nice: if there is an array of
	// objects with scalar tails, all but the last tail does have to
	// be initialized, because there is no way to say "skip forward".

ptrs := typ.PtrBytes / goarch.PtrSize
	if typ.Size_ == dataSize { // Single element
		if ptrs <= ptrBits { // Single small element
			m := readUintptr(typ.GCData)
			h = h.write(m, ptrs)
		} else { // Single large element
			p := typ.GCData
			for {
				h = h.write(readUintptr(p), ptrBits)
				p = addb(p, ptrBits/8)
				ptrs -= ptrBits
				if ptrs <= ptrBits {
					break
				}
			}
			m := readUintptr(p)
			h = h.write(m, ptrs)
		}
	} else { // Repeated element
		words := typ.Size_ / goarch.PtrSize // total words, including scalar tail
		if words <= ptrBits {               // Repeated small element
			n := dataSize / typ.Size_
			m := readUintptr(typ.GCData)
			// Make larger unit to repeat
			for words <= ptrBits/2 {
				if n&1 != 0 {
					h = h.write(m, words)
				}
				n /= 2
				m |= m << words
				ptrs += words
				words *= 2
				if n == 1 {
					break
				}
			}
			for n > 1 {
				h = h.write(m, words)
				n--
			}
			h = h.write(m, ptrs)
		} else { // Repeated large element
			for i := uintptr(0); true; i += typ.Size_ {
				p := typ.GCData
				j := ptrs
				for j > ptrBits {
					h = h.write(readUintptr(p), ptrBits)
					p = addb(p, ptrBits/8)
					j -= ptrBits
				}
				m := readUintptr(p)
				h = h.write(m, j)
				if i+typ.Size_ == dataSize {
					break // don't need the trailing nonptr bits on the last element.
				}
				// Pad with zeros to the start of the next element.
				h = h.pad(typ.Size_ - typ.PtrBytes)
			}
		}
	}
	h.flush(x, size)

if doubleCheck {
		h := heapBitsForAddr(x, size)
		for i := uintptr(0); i < size; i += goarch.PtrSize {
			// Compute the pointer bit we want at offset i.
			want := false
			if i < dataSize {
				off := i % typ.Size_
				if off < typ.PtrBytes {
					j := off / goarch.PtrSize
					want = *addb(typ.GCData, j/8)>>(j%8)&1 != 0
				}
			}
			if want {
				var addr uintptr
				h, addr = h.next()
				if addr != x+i {
					throw("heapBitsSetType: pointer entry not correct")
				}
			}
		}
		if _, addr := h.next(); addr != 0 {
			throw("heapBitsSetType: extra pointer")
		}
	}
}

// For goexperiment.AllocHeaders
func heapSetType(x, dataSize uintptr, typ *_type, header **_type, span *mspan) (scanSize uintptr) {
	return 0
}

// Testing.

// Returns GC type info for the pointer stored in ep for testing.
// If ep points to the stack, only static live information will be returned
// (i.e. not for objects which are only dynamically live stack objects).
func getgcmask(ep any) (mask []byte) {
	e := *efaceOf(&ep)
	p := e.data
	t := e._type
	// data or bss
	for _, datap := range activeModules() {
		// data
		if datap.data <= uintptr(p) && uintptr(p) < datap.edata {
			bitmap := datap.gcdatamask.bytedata
			n := (*ptrtype)(unsafe.Pointer(t)).Elem.Size_
			mask = make([]byte, n/goarch.PtrSize)
			for i := uintptr(0); i < n; i += goarch.PtrSize {
				off := (uintptr(p) + i - datap.data) / goarch.PtrSize
				mask[i/goarch.PtrSize] = (*addb(bitmap, off/8) >> (off % 8)) & 1
			}
			return
		}

// bss
		if datap.bss <= uintptr(p) && uintptr(p) < datap.ebss {
			bitmap := datap.gcbssmask.bytedata
			n := (*ptrtype)(unsafe.Pointer(t)).Elem.Size_
			mask = make([]byte, n/goarch.PtrSize)
			for i := uintptr(0); i < n; i += goarch.PtrSize {
				off := (uintptr(p) + i - datap.bss) / goarch.PtrSize
				mask[i/goarch.PtrSize] = (*addb(bitmap, off/8) >> (off % 8)) & 1
			}
			return
		}
	}

// heap
	if base, s, _ := findObject(uintptr(p), 0, 0); base != 0 {
		if s.spanclass.noscan() {
			return nil
		}
		n := s.elemsize
		hbits := heapBitsForAddr(base, n)
		mask = make([]byte, n/goarch.PtrSize)
		for {
			var addr uintptr
			if hbits, addr = hbits.next(); addr == 0 {
				break
			}
			mask[(addr-base)/goarch.PtrSize] = 1
		}
		// Callers expect this mask to end at the last pointer.
		for len(mask) > 0 && mask[len(mask)-1] == 0 {
			mask = mask[:len(mask)-1]
		}

// Make sure we keep ep alive. We may have stopped referencing
		// ep's data pointer sometime before this point and it's possible
		// for that memory to get freed.
		KeepAlive(ep)
		return
	}

// stack
	if gp := getg(); gp.m.curg.stack.lo <= uintptr(p) && uintptr(p) < gp.m.curg.stack.hi {
		found := false
		var u unwinder
		for u.initAt(gp.m.curg.sched.pc, gp.m.curg.sched.sp, 0, gp.m.curg, 0); u.valid(); u.next() {
			if u.frame.sp <= uintptr(p) && uintptr(p) < u.frame.varp {
				found = true
				break
			}
		}
		if found {
			locals, _, _ := u.frame.getStackMap(false)
			if locals.n == 0 {
				return
			}
			size := uintptr(locals.n) * goarch.PtrSize
			n := (*ptrtype)(unsafe.Pointer(t)).Elem.Size_
			mask = make([]byte, n/goarch.PtrSize)
			for i := uintptr(0); i < n; i += goarch.PtrSize {
				off := (uintptr(p) + i - u.frame.varp + size) / goarch.PtrSize
				mask[i/goarch.PtrSize] = locals.ptrbit(off)
			}
		}
		return
	}

// otherwise, not something the GC knows about.
	// possibly read-only data, like malloc(0).
	// must not have pointers
	return
}

// userArenaHeapBitsSetType is the equivalent of heapBitsSetType but for
// non-slice-backing-store Go values allocated in a user arena chunk. It
// sets up the heap bitmap for the value with type typ allocated at address ptr.
// base is the base address of the arena chunk.
func userArenaHeapBitsSetType(typ *_type, ptr unsafe.Pointer, s *mspan) {
	base := s.base()
	h := writeHeapBitsForAddr(uintptr(ptr))

// Our last allocation might have ended right at a noMorePtrs mark,
	// which we would not have erased. We need to erase that mark here,
	// because we're going to start adding new heap bitmap bits.
	// We only need to clear one mark, because below we make sure to
	// pad out the bits with zeroes and only write one noMorePtrs bit
	// for each new object.
	// (This is only necessary at noMorePtrs boundaries, as noMorePtrs
	// marks within an object allocated with newAt will be erased by
	// the normal writeHeapBitsForAddr mechanism.)
	//
	// Note that we skip this if this is the first allocation in the
	// arena because there's definitely no previous noMorePtrs mark
	// (in fact, we *must* do this, because we're going to try to back
	// up a pointer to fix this up).
	if uintptr(ptr)%(8*goarch.PtrSize*goarch.PtrSize) == 0 && uintptr(ptr) != base {
		// Back up one pointer and rewrite that pointer. That will
		// cause the writeHeapBits implementation to clear the
		// noMorePtrs bit we need to clear.
		r := heapBitsForAddr(uintptr(ptr)-goarch.PtrSize, goarch.PtrSize)
		_, p := r.next()
		b := uintptr(0)
		if p == uintptr(ptr)-goarch.PtrSize {
			b = 1
		}
		h = writeHeapBitsForAddr(uintptr(ptr) - goarch.PtrSize)
		h = h.write(b, 1)
	}

p := typ.GCData // start of 1-bit pointer mask (or GC program)
	var gcProgBits uintptr
	if typ.Kind_&kindGCProg != 0 {
		// Expand gc program, using the object itself for storage.
		gcProgBits = runGCProg(addb(p, 4), (*byte)(ptr))
		p = (*byte)(ptr)
	}
	nb := typ.PtrBytes / goarch.PtrSize

for i := uintptr(0); i < nb; i += ptrBits {
		k := nb - i
		if k > ptrBits {
			k = ptrBits
		}
		h = h.write(readUintptr(addb(p, i/8)), k)
	}
	// Note: we call pad here to ensure we emit explicit 0 bits
	// for the pointerless tail of the object. This ensures that
	// there's only a single noMorePtrs mark for the next object
	// to clear. We don't need to do this to clear stale noMorePtrs
	// markers from previous uses because arena chunk pointer bitmaps
	// are always fully cleared when reused.
	h = h.pad(typ.Size_ - typ.PtrBytes)
	h.flush(uintptr(ptr), typ.Size_)

if typ.Kind_&kindGCProg != 0 {
		// Zero out temporary ptrmask buffer inside object.
		memclrNoHeapPointers(ptr, (gcProgBits+7)/8)
	}

// Double-check that the bitmap was written out correctly.
	//
	// Derived from heapBitsSetType.
	const doubleCheck = false
	if doubleCheck {
		size := typ.Size_
		x := uintptr(ptr)
		h := heapBitsForAddr(x, size)
		for i := uintptr(0); i < size; i += goarch.PtrSize {
			// Compute the pointer bit we want at offset i.
			want := false
			off := i % typ.Size_
			if off < typ.PtrBytes {
				j := off / goarch.PtrSize
				want = *addb(typ.GCData, j/8)>>(j%8)&1 != 0
			}
			if want {
				var addr uintptr
				h, addr = h.next()
				if addr != x+i {
					throw("userArenaHeapBitsSetType: pointer entry not correct")
				}
			}
		}
		if _, addr := h.next(); addr != 0 {
			throw("userArenaHeapBitsSetType: extra pointer")
		}
	}
}

// For goexperiment.AllocHeaders.
type typePointers struct {
	addr uintptr
}

// For goexperiment.AllocHeaders.
//
//go:nosplit
func (span *mspan) typePointersOf(addr, size uintptr) typePointers {
	panic("not implemented")
}

// For goexperiment.AllocHeaders.
//
//go:nosplit
func (span *mspan) typePointersOfUnchecked(addr uintptr) typePointers {
	panic("not implemented")
}

// For goexperiment.AllocHeaders.
//
//go:nosplit
func (tp typePointers) nextFast() (typePointers, uintptr) {
	panic("not implemented")
}

// For goexperiment.AllocHeaders.
//
//go:nosplit
func (tp typePointers) next(limit uintptr) (typePointers, uintptr) {
	panic("not implemented")
}

// For goexperiment.AllocHeaders.
//
//go:nosplit
func (tp typePointers) fastForward(n, limit uintptr) typePointers {
	panic("not implemented")
}

// For goexperiment.AllocHeaders, to pass TestIntendedInlining.
func (s *mspan) writeUserArenaHeapBits() {
	panic("not implemented")
}

// For goexperiment.AllocHeaders, to pass TestIntendedInlining.
func heapBitsSlice() {
	panic("not implemented")
}

Batal

⬅ src 738 item

Nama	Tipe	Ukuran	Diubah	Aksi
📁asan	dir	—	2024-02-02 18:09	📂 Buka
📁cgo	dir	—	2024-02-02 18:09	📂 Buka
📁coverage	dir	—	2024-02-02 18:09	📂 Buka
📁debug	dir	—	2024-02-02 18:09	📂 Buka
📁internal	dir	—	2024-02-02 18:09	📂 Buka
📁metrics	dir	—	2024-02-02 18:09	📂 Buka
📁msan	dir	—	2024-02-02 18:09	📂 Buka
📁pprof	dir	—	2024-02-02 18:09	📂 Buka
📁race	dir	—	2024-02-02 18:09	📂 Buka
📁testdata	dir	—	2024-02-02 18:09	📂 Buka
📁trace	dir	—	2024-02-02 18:09	📂 Buka
📝HACKING.md	md	13.9 KB	2024-02-02 18:09	✏️ 👁️
📄Makefile	file	178 B	2024-02-02 18:09	✏️ 👁️
🔵abi_test.go	go	2.8 KB	2024-02-02 18:09	✏️ 👁️
🔵alg.go	go	11 KB	2024-02-02 18:09	✏️ 👁️
🔵align_runtime_test.go	go	1.8 KB	2024-02-02 18:09	✏️ 👁️
🔵align_test.go	go	5.4 KB	2024-02-02 18:09	✏️ 👁️
🔵arena.go	go	31.7 KB	2024-02-02 18:09	✏️ 👁️
🔵arena_test.go	go	13.4 KB	2024-02-02 18:09	✏️ 👁️
🔵asan.go	go	1.5 KB	2024-02-02 18:09	✏️ 👁️
🔵asan0.go	go	760 B	2024-02-02 18:09	✏️ 👁️
📄asan_amd64.s	s	2.4 KB	2024-02-02 18:09	✏️ 👁️
📄asan_arm64.s	s	2.1 KB	2024-02-02 18:09	✏️ 👁️
📄asan_loong64.s	s	2.1 KB	2024-02-02 18:09	✏️ 👁️
📄asan_ppc64le.s	s	2.8 KB	2024-02-02 18:09	✏️ 👁️
📄asan_riscv64.s	s	1.9 KB	2024-02-02 18:09	✏️ 👁️
📄asm.s	s	719 B	2024-02-02 18:09	✏️ 👁️
📄asm_386.s	s	42.5 KB	2024-02-02 18:09	✏️ 👁️
📄asm_amd64.h	h	631 B	2024-02-02 18:09	✏️ 👁️
📄asm_amd64.s	s	60.1 KB	2024-02-02 18:09	✏️ 👁️
📄asm_arm.s	s	31.6 KB	2024-02-02 18:09	✏️ 👁️
📄asm_arm64.s	s	43.3 KB	2024-02-02 18:09	✏️ 👁️
📄asm_loong64.s	s	27.6 KB	2024-02-02 18:09	✏️ 👁️
📄asm_mips64x.s	s	24.3 KB	2024-02-02 18:09	✏️ 👁️
📄asm_mipsx.s	s	25.8 KB	2024-02-02 18:09	✏️ 👁️
📄asm_ppc64x.h	h	1.9 KB	2024-02-02 18:09	✏️ 👁️
📄asm_ppc64x.s	s	45.2 KB	2024-02-02 18:09	✏️ 👁️
📄asm_riscv64.s	s	27 KB	2024-02-02 18:09	✏️ 👁️
📄asm_s390x.s	s	27.5 KB	2024-02-02 18:09	✏️ 👁️
📄asm_wasm.s	s	11.8 KB	2024-02-02 18:09	✏️ 👁️
📄atomic_arm64.s	s	259 B	2024-02-02 18:09	✏️ 👁️
📄atomic_loong64.s	s	245 B	2024-02-02 18:09	✏️ 👁️
📄atomic_mips64x.s	s	300 B	2024-02-02 18:09	✏️ 👁️
📄atomic_mipsx.s	s	262 B	2024-02-02 18:09	✏️ 👁️
🔵atomic_pointer.go	go	3.7 KB	2024-02-02 18:09	✏️ 👁️
📄atomic_ppc64x.s	s	437 B	2024-02-02 18:09	✏️ 👁️
📄atomic_riscv64.s	s	275 B	2024-02-02 18:09	✏️ 👁️
🔵auxv_none.go	go	298 B	2024-02-02 18:09	✏️ 👁️
🔵callers_test.go	go	12.1 KB	2024-02-02 18:09	✏️ 👁️
🔵cgo.go	go	2.5 KB	2024-02-02 18:09	✏️ 👁️
🔵cgo_mmap.go	go	2.4 KB	2024-02-02 18:09	✏️ 👁️
🔵cgo_ppc64x.go	go	418 B	2024-02-02 18:09	✏️ 👁️
🔵cgo_sigaction.go	go	3.3 KB	2024-02-02 18:09	✏️ 👁️
🔵cgocall.go	go	23.2 KB	2024-02-02 18:09	✏️ 👁️
🔵cgocallback.go	go	317 B	2024-02-02 18:09	✏️ 👁️
🔵cgocheck.go	go	8 KB	2024-02-02 18:09	✏️ 👁️
🔵chan.go	go	23.7 KB	2024-02-02 18:09	✏️ 👁️
🔵chan_test.go	go	23.4 KB	2024-02-02 18:09	✏️ 👁️
🔵chanbarrier_test.go	go	1.4 KB	2024-02-02 18:09	✏️ 👁️
🔵checkptr.go	go	3.3 KB	2024-02-02 18:09	✏️ 👁️
🔵checkptr_test.go	go	2.9 KB	2024-02-02 18:09	✏️ 👁️
🔵closure_test.go	go	937 B	2024-02-02 18:09	✏️ 👁️
🔵compiler.go	go	410 B	2024-02-02 18:09	✏️ 👁️
🔵complex.go	go	1.6 KB	2024-02-02 18:09	✏️ 👁️
🔵complex_test.go	go	1.1 KB	2024-02-02 18:09	✏️ 👁️
🔵conv_wasm_test.go	go	3 KB	2024-02-02 18:09	✏️ 👁️
🔵coro.go	go	4.9 KB	2024-02-02 18:09	✏️ 👁️
🔵covercounter.go	go	749 B	2024-02-02 18:09	✏️ 👁️
🔵covermeta.go	go	2.4 KB	2024-02-02 18:09	✏️ 👁️
🔵cpuflags.go	go	810 B	2024-02-02 18:09	✏️ 👁️
🔵cpuflags_amd64.go	go	533 B	2024-02-02 18:09	✏️ 👁️
🔵cpuflags_arm64.go	go	312 B	2024-02-02 18:09	✏️ 👁️
🔵cpuprof.go	go	7.9 KB	2024-02-02 18:09	✏️ 👁️
🔵cputicks.go	go	437 B	2024-02-02 18:09	✏️ 👁️
🔵crash_cgo_test.go	go	23.4 KB	2024-02-02 18:09	✏️ 👁️
🔵crash_test.go	go	23.1 KB	2024-02-02 18:09	✏️ 👁️
🔵crash_unix_test.go	go	9.2 KB	2024-02-02 18:09	✏️ 👁️
🔵create_file_nounix.go	go	305 B	2024-02-02 18:09	✏️ 👁️
🔵create_file_unix.go	go	368 B	2024-02-02 18:09	✏️ 👁️
🔵debug.go	go	3.5 KB	2024-02-02 18:09	✏️ 👁️
🔵debug_test.go	go	8 KB	2024-02-02 18:09	✏️ 👁️
🔵debugcall.go	go	6.7 KB	2024-02-02 18:09	✏️ 👁️
🔵debuglog.go	go	18.2 KB	2024-02-02 18:09	✏️ 👁️
🔵debuglog_off.go	go	357 B	2024-02-02 18:09	✏️ 👁️
🔵debuglog_on.go	go	1.1 KB	2024-02-02 18:09	✏️ 👁️
🔵debuglog_test.go	go	4.9 KB	2024-02-02 18:09	✏️ 👁️
🔵defer_test.go	go	11.4 KB	2024-02-02 18:09	✏️ 👁️
🔵defs1_linux.go	go	845 B	2024-02-02 18:09	✏️ 👁️
🔵defs1_netbsd_386.go	go	2.9 KB	2024-02-02 18:09	✏️ 👁️
🔵defs1_netbsd_amd64.go	go	3.1 KB	2024-02-02 18:09	✏️ 👁️
🔵defs1_netbsd_arm.go	go	3 KB	2024-02-02 18:09	✏️ 👁️
🔵defs1_netbsd_arm64.go	go	3.3 KB	2024-02-02 18:09	✏️ 👁️
🔵defs1_solaris_amd64.go	go	4 KB	2024-02-02 18:09	✏️ 👁️
🔵defs2_linux.go	go	3.2 KB	2024-02-02 18:09	✏️ 👁️
🔵defs3_linux.go	go	1.1 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_aix.go	go	4.2 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_aix_ppc64.go	go	3.6 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_arm_linux.go	go	2.7 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_darwin.go	go	4.2 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_darwin_amd64.go	go	6.3 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_darwin_arm64.go	go	4.2 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_dragonfly.go	go	2.7 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_dragonfly_amd64.go	go	3.4 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_freebsd.go	go	4 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_freebsd_386.go	go	4.5 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_freebsd_amd64.go	go	4.8 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_freebsd_arm.go	go	3.9 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_freebsd_arm64.go	go	4.2 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_freebsd_riscv64.go	go	4.2 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_illumos_amd64.go	go	285 B	2024-02-02 18:09	✏️ 👁️
🔵defs_linux.go	go	2.9 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_linux_386.go	go	4.2 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_linux_amd64.go	go	4.7 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_linux_arm.go	go	3.9 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_linux_arm64.go	go	3.6 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_linux_loong64.go	go	3.4 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_linux_mips64x.go	go	3.6 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_linux_mipsx.go	go	3.6 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_linux_ppc64.go	go	3.7 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_linux_ppc64le.go	go	3.7 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_linux_riscv64.go	go	3.8 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_linux_s390x.go	go	3.2 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_netbsd.go	go	2.8 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_netbsd_386.go	go	855 B	2024-02-02 18:09	✏️ 👁️
🔵defs_netbsd_amd64.go	go	1 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_netbsd_arm.go	go	764 B	2024-02-02 18:09	✏️ 👁️
🔵defs_openbsd.go	go	3.1 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_openbsd_386.go	go	2.9 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_openbsd_amd64.go	go	3.1 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_openbsd_arm.go	go	3 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_openbsd_arm64.go	go	2.8 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_openbsd_mips64.go	go	2.8 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_openbsd_ppc64.go	go	3 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_openbsd_riscv64.go	go	2.9 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_plan9_386.go	go	1.6 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_plan9_amd64.go	go	1.8 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_plan9_arm.go	go	1.7 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_solaris.go	go	3.3 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_solaris_amd64.go	go	1004 B	2024-02-02 18:09	✏️ 👁️
🔵defs_windows.go	go	2.3 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_windows_386.go	go	2.3 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_windows_amd64.go	go	3.2 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_windows_arm.go	go	2.6 KB	2024-02-02 18:09	✏️ 👁️
🔵defs_windows_arm64.go	go	3.1 KB	2024-02-02 18:09	✏️ 👁️
📄duff_386.s	s	8.2 KB	2024-02-02 18:09	✏️ 👁️
📄duff_amd64.s	s	5.6 KB	2024-02-02 18:09	✏️ 👁️
📄duff_arm.s	s	7.1 KB	2024-02-02 18:09	✏️ 👁️
📄duff_arm64.s	s	5.3 KB	2024-02-02 18:09	✏️ 👁️
📄duff_loong64.s	s	11.9 KB	2024-02-02 18:09	✏️ 👁️
📄duff_mips64x.s	s	11.3 KB	2024-02-02 18:09	✏️ 👁️
📄duff_ppc64x.s	s	7.1 KB	2024-02-02 18:09	✏️ 👁️
📄duff_riscv64.s	s	11.4 KB	2024-02-02 18:09	✏️ 👁️
📄duff_s390x.s	s	507 B	2024-02-02 18:09	✏️ 👁️
🔵ehooks_test.go	go	2 KB	2024-02-02 18:09	✏️ 👁️
🔵env_plan9.go	go	3 KB	2024-02-02 18:09	✏️ 👁️
🔵env_posix.go	go	1.6 KB	2024-02-02 18:09	✏️ 👁️
🔵env_test.go	go	1.2 KB	2024-02-02 18:09	✏️ 👁️
🔵error.go	go	9.3 KB	2024-02-02 18:09	✏️ 👁️
🔵example_test.go	go	1.5 KB	2024-02-02 18:09	✏️ 👁️
🔵exithook.go	go	2.3 KB	2024-02-02 18:09	✏️ 👁️
🔵export_aix_test.go	go	207 B	2024-02-02 18:09	✏️ 👁️
🔵export_arm_test.go	go	226 B	2024-02-02 18:09	✏️ 👁️
🔵export_darwin_test.go	go	207 B	2024-02-02 18:09	✏️ 👁️
🔵export_debug_amd64_test.go	go	3.6 KB	2024-02-02 18:09	✏️ 👁️
🔵export_debug_arm64_test.go	go	3.5 KB	2024-02-02 18:09	✏️ 👁️
🔵export_debug_ppc64le_test.go	go	3.5 KB	2024-02-02 18:09	✏️ 👁️
🔵export_debug_test.go	go	5.1 KB	2024-02-02 18:09	✏️ 👁️
🔵export_debuglog_test.go	go	1.3 KB	2024-02-02 18:09	✏️ 👁️
🔵export_linux_test.go	go	378 B	2024-02-02 18:09	✏️ 👁️
🔵export_mmap_test.go	go	429 B	2024-02-02 18:09	✏️ 👁️
🔵export_pipe2_test.go	go	310 B	2024-02-02 18:09	✏️ 👁️
🔵export_pipe_test.go	go	219 B	2024-02-02 18:09	✏️ 👁️
🔵export_test.go	go	50.5 KB	2024-02-02 18:09	✏️ 👁️
🔵export_unix_test.go	go	2.3 KB	2024-02-02 18:09	✏️ 👁️
🔵export_windows_test.go	go	903 B	2024-02-02 18:09	✏️ 👁️
🔵extern.go	go	18.6 KB	2024-02-02 18:09	✏️ 👁️
🔵fastlog2.go	go	1.2 KB	2024-02-02 18:09	✏️ 👁️
🔵fastlog2_test.go	go	784 B	2024-02-02 18:09	✏️ 👁️
🔵fastlog2table.go	go	904 B	2024-02-02 18:09	✏️ 👁️
🔵fds_nonunix.go	go	256 B	2024-02-02 18:09	✏️ 👁️
🔵fds_test.go	go	1.4 KB	2024-02-02 18:09	✏️ 👁️
🔵fds_unix.go	go	1.3 KB	2024-02-02 18:09	✏️ 👁️
🔵float.go	go	1.4 KB	2024-02-02 18:09	✏️ 👁️
🔵float_test.go	go	699 B	2024-02-02 18:09	✏️ 👁️
📄funcdata.h	h	2.5 KB	2024-02-02 18:09	✏️ 👁️
🔵gc_test.go	go	20.3 KB	2024-02-02 18:09	✏️ 👁️
🔵gcinfo_test.go	go	6 KB	2024-02-02 18:09	✏️ 👁️
📄go_tls.h	h	366 B	2024-02-02 18:09	✏️ 👁️
🔵hash32.go	go	1.6 KB	2024-02-02 18:09	✏️ 👁️
🔵hash64.go	go	1.9 KB	2024-02-02 18:09	✏️ 👁️
🔵hash_test.go	go	17.2 KB	2024-02-02 18:09	✏️ 👁️
🔵heap_test.go	go	529 B	2024-02-02 18:09	✏️ 👁️
🔵heapdump.go	go	17.9 KB	2024-02-02 18:09	✏️ 👁️
🔵histogram.go	go	7.3 KB	2024-02-02 18:09	✏️ 👁️
🔵histogram_test.go	go	3.5 KB	2024-02-02 18:09	✏️ 👁️
🔵iface.go	go	20.9 KB	2024-02-02 18:09	✏️ 👁️
🔵iface_test.go	go	7.5 KB	2024-02-02 18:09	✏️ 👁️
🔵import_test.go	go	1.4 KB	2024-02-02 18:09	✏️ 👁️
🔵importx_test.go	go	763 B	2024-02-02 18:09	✏️ 👁️
🔵lfstack.go	go	2 KB	2024-02-02 18:09	✏️ 👁️
🔵lfstack_test.go	go	2.7 KB	2024-02-02 18:09	✏️ 👁️
🔵libfuzzer.go	go	6.3 KB	2024-02-02 18:09	✏️ 👁️
📄libfuzzer_amd64.s	s	5 KB	2024-02-02 18:09	✏️ 👁️
📄libfuzzer_arm64.s	s	3.2 KB	2024-02-02 18:09	✏️ 👁️
🔵lock_futex.go	go	5.4 KB	2024-02-02 18:09	✏️ 👁️
🔵lock_js.go	go	7.3 KB	2024-02-02 18:09	✏️ 👁️
🔵lock_sema.go	go	6.8 KB	2024-02-02 18:09	✏️ 👁️
🔵lock_wasip1.go	go	2 KB	2024-02-02 18:09	✏️ 👁️
🔵lockrank.go	go	18.2 KB	2024-02-02 18:09	✏️ 👁️
🔵lockrank_off.go	go	1.2 KB	2024-02-02 18:09	✏️ 👁️
🔵lockrank_on.go	go	10.3 KB	2024-02-02 18:09	✏️ 👁️
🔵lockrank_test.go	go	856 B	2024-02-02 18:09	✏️ 👁️
🔵malloc.go	go	58.5 KB	2024-02-02 18:09	✏️ 👁️
🔵malloc_test.go	go	10.6 KB	2024-02-02 18:09	✏️ 👁️
🔵map.go	go	52.2 KB	2024-02-02 18:09	✏️ 👁️
🔵map_benchmark_test.go	go	10.6 KB	2024-02-02 18:09	✏️ 👁️
🔵map_fast32.go	go	12.7 KB	2024-02-02 18:09	✏️ 👁️
🔵map_fast64.go	go	12.9 KB	2024-02-02 18:09	✏️ 👁️
🔵map_faststr.go	go	14.3 KB	2024-02-02 18:09	✏️ 👁️
🔵map_test.go	go	31.7 KB	2024-02-02 18:09	✏️ 👁️
🔵mbarrier.go	go	13.8 KB	2024-02-02 18:09	✏️ 👁️
🔵mbitmap.go	go	22.5 KB	2024-02-02 18:09	✏️ 👁️
🔵mbitmap_allocheaders.go	go	44.7 KB	2024-02-02 18:09	✏️ 👁️
🔵mbitmap_noallocheaders.go	go	29 KB	2024-02-02 18:09	✏️ 👁️
🔵mcache.go	go	10 KB	2024-02-02 18:09	✏️ 👁️
🔵mcentral.go	go	8.1 KB	2024-02-02 18:09	✏️ 👁️
🔵mcheckmark.go	go	2.9 KB	2024-02-02 18:09	✏️ 👁️
🔵mem.go	go	6.7 KB	2024-02-02 18:09	✏️ 👁️
🔵mem_aix.go	go	2 KB	2024-02-02 18:09	✏️ 👁️
🔵mem_bsd.go	go	2.2 KB	2024-02-02 18:09	✏️ 👁️
🔵mem_darwin.go	go	2 KB	2024-02-02 18:09	✏️ 👁️
🔵mem_js.go	go	457 B	2024-02-02 18:09	✏️ 👁️
🔵mem_linux.go	go	5 KB	2024-02-02 18:09	✏️ 👁️
🔵mem_plan9.go	go	447 B	2024-02-02 18:09	✏️ 👁️
🔵mem_sbrk.go	go	4.2 KB	2024-02-02 18:09	✏️ 👁️
🔵mem_wasip1.go	go	392 B	2024-02-02 18:09	✏️ 👁️
🔵mem_wasm.go	go	488 B	2024-02-02 18:09	✏️ 👁️
🔵mem_windows.go	go	3.9 KB	2024-02-02 18:09	✏️ 👁️
📄memclr_386.s	s	2.4 KB	2024-02-02 18:09	✏️ 👁️
📄memclr_amd64.s	s	4.9 KB	2024-02-02 18:09	✏️ 👁️
📄memclr_arm.s	s	2.6 KB	2024-02-02 18:09	✏️ 👁️
📄memclr_arm64.s	s	3.6 KB	2024-02-02 18:09	✏️ 👁️
📄memclr_loong64.s	s	843 B	2024-02-02 18:09	✏️ 👁️
📄memclr_mips64x.s	s	1.7 KB	2024-02-02 18:09	✏️ 👁️
📄memclr_mipsx.s	s	1.3 KB	2024-02-02 18:09	✏️ 👁️
📄memclr_plan9_386.s	s	983 B	2024-02-02 18:09	✏️ 👁️
📄memclr_plan9_amd64.s	s	511 B	2024-02-02 18:09	✏️ 👁️
📄memclr_ppc64x.s	s	4.4 KB	2024-02-02 18:09	✏️ 👁️
📄memclr_riscv64.s	s	1.7 KB	2024-02-02 18:09	✏️ 👁️
📄memclr_s390x.s	s	2 KB	2024-02-02 18:09	✏️ 👁️
📄memclr_wasm.s	s	485 B	2024-02-02 18:09	✏️ 👁️
📄memmove_386.s	s	4.4 KB	2024-02-02 18:09	✏️ 👁️
📄memmove_amd64.s	s	12.5 KB	2024-02-02 18:09	✏️ 👁️
📄memmove_arm.s	s	5.9 KB	2024-02-02 18:09	✏️ 👁️
📄memmove_arm64.s	s	6 KB	2024-02-02 18:09	✏️ 👁️
🔵memmove_linux_amd64_test.go	go	1.5 KB	2024-02-02 18:09	✏️ 👁️
📄memmove_loong64.s	s	1.9 KB	2024-02-02 18:09	✏️ 👁️
📄memmove_mips64x.s	s	1.8 KB	2024-02-02 18:09	✏️ 👁️
📄memmove_mipsx.s	s	4.4 KB	2024-02-02 18:09	✏️ 👁️
📄memmove_plan9_386.s	s	3.1 KB	2024-02-02 18:09	✏️ 👁️
📄memmove_plan9_amd64.s	s	3 KB	2024-02-02 18:09	✏️ 👁️
📄memmove_ppc64x.s	s	4.9 KB	2024-02-02 18:09	✏️ 👁️
📄memmove_riscv64.s	s	5.5 KB	2024-02-02 18:09	✏️ 👁️
📄memmove_s390x.s	s	2.9 KB	2024-02-02 18:09	✏️ 👁️
🔵memmove_test.go	go	21.2 KB	2024-02-02 18:09	✏️ 👁️
📄memmove_wasm.s	s	479 B	2024-02-02 18:09	✏️ 👁️
🔵metrics.go	go	26 KB	2024-02-02 18:09	✏️ 👁️
🔵metrics_test.go	go	42.5 KB	2024-02-02 18:09	✏️ 👁️
🔵mfinal.go	go	18.9 KB	2024-02-02 18:09	✏️ 👁️
🔵mfinal_test.go	go	5.6 KB	2024-02-02 18:09	✏️ 👁️
🔵mfixalloc.go	go	3.1 KB	2024-02-02 18:09	✏️ 👁️
🔵mgc.go	go	59.3 KB	2024-02-02 18:09	✏️ 👁️
🔵mgclimit.go	go	17.3 KB	2024-02-02 18:09	✏️ 👁️
🔵mgclimit_test.go	go	9 KB	2024-02-02 18:09	✏️ 👁️
🔵mgcmark.go	go	53.1 KB	2024-02-02 18:09	✏️ 👁️
🔵mgcpacer.go	go	55.4 KB	2024-02-02 18:09	✏️ 👁️
🔵mgcpacer_test.go	go	39.3 KB	2024-02-02 18:09	✏️ 👁️
🔵mgcscavenge.go	go	52.3 KB	2024-02-02 18:09	✏️ 👁️
🔵mgcscavenge_test.go	go	25.2 KB	2024-02-02 18:09	✏️ 👁️
🔵mgcstack.go	go	10.6 KB	2024-02-02 18:09	✏️ 👁️
🔵mgcsweep.go	go	32.3 KB	2024-02-02 18:09	✏️ 👁️
🔵mgcwork.go	go	12.9 KB	2024-02-02 18:09	✏️ 👁️
🔵mheap.go	go	72.6 KB	2024-02-02 18:09	✏️ 👁️
🔵minmax.go	go	1.5 KB	2024-02-02 18:09	✏️ 👁️
🔵minmax_test.go	go	3.3 KB	2024-02-02 18:09	✏️ 👁️
🔵mkduff.go	go	8 KB	2024-02-02 18:09	✏️ 👁️
🔵mkfastlog2table.go	go	3.1 KB	2024-02-02 18:09	✏️ 👁️
🔵mklockrank.go	go	9 KB	2024-02-02 18:09	✏️ 👁️
🔵mkpreempt.go	go	15.3 KB	2024-02-02 18:09	✏️ 👁️
🔵mksizeclasses.go	go	9.5 KB	2024-02-02 18:09	✏️ 👁️
🔵mmap.go	go	844 B	2024-02-02 18:09	✏️ 👁️
🔵mpagealloc.go	go	39.2 KB	2024-02-02 18:09	✏️ 👁️
🔵mpagealloc_32bit.go	go	4.6 KB	2024-02-02 18:09	✏️ 👁️
🔵mpagealloc_64bit.go	go	9.3 KB	2024-02-02 18:09	✏️ 👁️
🔵mpagealloc_test.go	go	32.6 KB	2024-02-02 18:09	✏️ 👁️
🔵mpagecache.go	go	5.6 KB	2024-02-02 18:09	✏️ 👁️
🔵mpagecache_test.go	go	10.8 KB	2024-02-02 18:09	✏️ 👁️
🔵mpallocbits.go	go	12.6 KB	2024-02-02 18:09	✏️ 👁️
🔵mpallocbits_test.go	go	13.7 KB	2024-02-02 18:09	✏️ 👁️
🔵mprof.go	go	47.4 KB	2024-02-02 18:09	✏️ 👁️
🔵mranges.go	go	14.5 KB	2024-02-02 18:09	✏️ 👁️
🔵mranges_test.go	go	5.7 KB	2024-02-02 18:09	✏️ 👁️
🔵msan.go	go	1.5 KB	2024-02-02 18:09	✏️ 👁️
🔵msan0.go	go	725 B	2024-02-02 18:09	✏️ 👁️
📄msan_amd64.s	s	2.3 KB	2024-02-02 18:09	✏️ 👁️
📄msan_arm64.s	s	2 KB	2024-02-02 18:09	✏️ 👁️
📄msan_loong64.s	s	2 KB	2024-02-02 18:09	✏️ 👁️
🔵msize_allocheaders.go	go	1.3 KB	2024-02-02 18:09	✏️ 👁️
🔵msize_noallocheaders.go	go	915 B	2024-02-02 18:09	✏️ 👁️
🔵mspanset.go	go	13.1 KB	2024-02-02 18:09	✏️ 👁️
🔵mstats.go	go	33.8 KB	2024-02-02 18:09	✏️ 👁️
🔵mwbbuf.go	go	8.1 KB	2024-02-02 18:09	✏️ 👁️
🔵nbpipe_pipe.go	go	405 B	2024-02-02 18:09	✏️ 👁️
🔵nbpipe_pipe2.go	go	344 B	2024-02-02 18:09	✏️ 👁️
🔵nbpipe_pipe_test.go	go	706 B	2024-02-02 18:09	✏️ 👁️
🔵nbpipe_test.go	go	2 KB	2024-02-02 18:09	✏️ 👁️
🔵net_plan9.go	go	645 B	2024-02-02 18:09	✏️ 👁️
🔵netpoll.go	go	20.5 KB	2024-02-02 18:09	✏️ 👁️
🔵netpoll_aix.go	go	5.1 KB	2024-02-02 18:09	✏️ 👁️
🔵netpoll_epoll.go	go	4.4 KB	2024-02-02 18:09	✏️ 👁️
🔵netpoll_fake.go	go	664 B	2024-02-02 18:09	✏️ 👁️
🔵netpoll_kqueue.go	go	5.6 KB	2024-02-02 18:09	✏️ 👁️
🔵netpoll_os_test.go	go	520 B	2024-02-02 18:09	✏️ 👁️
🔵netpoll_solaris.go	go	11.2 KB	2024-02-02 18:09	✏️ 👁️
🔵netpoll_stub.go	go	1.5 KB	2024-02-02 18:09	✏️ 👁️
🔵netpoll_wasip1.go	go	6.1 KB	2024-02-02 18:09	✏️ 👁️
🔵netpoll_windows.go	go	4 KB	2024-02-02 18:09	✏️ 👁️
🔵nonwindows_stub.go	go	729 B	2024-02-02 18:09	✏️ 👁️
🔵norace_linux_test.go	go	915 B	2024-02-02 18:09	✏️ 👁️
🔵norace_test.go	go	983 B	2024-02-02 18:09	✏️ 👁️
🔵numcpu_freebsd_test.go	go	381 B	2024-02-02 18:09	✏️ 👁️
🔵os2_aix.go	go	20.9 KB	2024-02-02 18:09	✏️ 👁️
🔵os2_freebsd.go	go	302 B	2024-02-02 18:09	✏️ 👁️
🔵os2_openbsd.go	go	296 B	2024-02-02 18:09	✏️ 👁️
🔵os2_plan9.go	go	1.5 KB	2024-02-02 18:09	✏️ 👁️
🔵os2_solaris.go	go	320 B	2024-02-02 18:09	✏️ 👁️
🔵os3_plan9.go	go	3.9 KB	2024-02-02 18:09	✏️ 👁️
🔵os3_solaris.go	go	17.6 KB	2024-02-02 18:09	✏️ 👁️
🔵os_aix.go	go	8.9 KB	2024-02-02 18:09	✏️ 👁️
🔵os_android.go	go	463 B	2024-02-02 18:09	✏️ 👁️
🔵os_darwin.go	go	11.9 KB	2024-02-02 18:09	✏️ 👁️
🔵os_darwin_arm64.go	go	329 B	2024-02-02 18:09	✏️ 👁️
🔵os_dragonfly.go	go	7.1 KB	2024-02-02 18:09	✏️ 👁️
🔵os_freebsd.go	go	11.6 KB	2024-02-02 18:09	✏️ 👁️
🔵os_freebsd2.go	go	603 B	2024-02-02 18:09	✏️ 👁️
🔵os_freebsd_amd64.go	go	658 B	2024-02-02 18:09	✏️ 👁️
🔵os_freebsd_arm.go	go	1.4 KB	2024-02-02 18:09	✏️ 👁️
🔵os_freebsd_arm64.go	go	320 B	2024-02-02 18:09	✏️ 👁️
🔵os_freebsd_noauxv.go	go	241 B	2024-02-02 18:09	✏️ 👁️
🔵os_freebsd_riscv64.go	go	198 B	2024-02-02 18:09	✏️ 👁️
🔵os_illumos.go	go	3.9 KB	2024-02-02 18:09	✏️ 👁️
🔵os_js.go	go	767 B	2024-02-02 18:09	✏️ 👁️
🔵os_linux.go	go	25.7 KB	2024-02-02 18:09	✏️ 👁️
🔵os_linux_arm.go	go	1.5 KB	2024-02-02 18:09	✏️ 👁️
🔵os_linux_arm64.go	go	478 B	2024-02-02 18:09	✏️ 👁️
🔵os_linux_be64.go	go	806 B	2024-02-02 18:09	✏️ 👁️
🔵os_linux_generic.go	go	870 B	2024-02-02 18:09	✏️ 👁️
🔵os_linux_loong64.go	go	263 B	2024-02-02 18:09	✏️ 👁️
🔵os_linux_mips64x.go	go	996 B	2024-02-02 18:09	✏️ 👁️
🔵os_linux_mipsx.go	go	987 B	2024-02-02 18:09	✏️ 👁️
🔵os_linux_noauxv.go	go	337 B	2024-02-02 18:09	✏️ 👁️
🔵os_linux_novdso.go	go	347 B	2024-02-02 18:09	✏️ 👁️
🔵os_linux_ppc64x.go	go	526 B	2024-02-02 18:09	✏️ 👁️
🔵os_linux_riscv64.go	go	198 B	2024-02-02 18:09	✏️ 👁️
🔵os_linux_s390x.go	go	825 B	2024-02-02 18:09	✏️ 👁️
🔵os_linux_x86.go	go	234 B	2024-02-02 18:09	✏️ 👁️
🔵os_netbsd.go	go	10.1 KB	2024-02-02 18:09	✏️ 👁️
🔵os_netbsd_386.go	go	617 B	2024-02-02 18:09	✏️ 👁️
🔵os_netbsd_amd64.go	go	614 B	2024-02-02 18:09	✏️ 👁️
🔵os_netbsd_arm.go	go	1.1 KB	2024-02-02 18:09	✏️ 👁️
🔵os_netbsd_arm64.go	go	769 B	2024-02-02 18:09	✏️ 👁️
🔵os_nonopenbsd.go	go	437 B	2024-02-02 18:09	✏️ 👁️
🔵os_only_solaris.go	go	357 B	2024-02-02 18:09	✏️ 👁️
🔵os_openbsd.go	go	6.2 KB	2024-02-02 18:09	✏️ 👁️
🔵os_openbsd_arm.go	go	662 B	2024-02-02 18:09	✏️ 👁️
🔵os_openbsd_arm64.go	go	329 B	2024-02-02 18:09	✏️ 👁️
🔵os_openbsd_libc.go	go	1.5 KB	2024-02-02 18:09	✏️ 👁️
🔵os_openbsd_mips64.go	go	329 B	2024-02-02 18:09	✏️ 👁️
🔵os_openbsd_syscall.go	go	1.4 KB	2024-02-02 18:09	✏️ 👁️
🔵os_openbsd_syscall1.go	go	441 B	2024-02-02 18:09	✏️ 👁️
🔵os_openbsd_syscall2.go	go	2.5 KB	2024-02-02 18:09	✏️ 👁️
🔵os_plan9.go	go	10.2 KB	2024-02-02 18:09	✏️ 👁️
🔵os_plan9_arm.go	go	375 B	2024-02-02 18:09	✏️ 👁️
🔵os_solaris.go	go	6.6 KB	2024-02-02 18:09	✏️ 👁️
🔵os_unix.go	go	436 B	2024-02-02 18:09	✏️ 👁️
🔵os_unix_nonlinux.go	go	374 B	2024-02-02 18:09	✏️ 👁️
🔵os_wasip1.go	go	7 KB	2024-02-02 18:09	✏️ 👁️
🔵os_wasm.go	go	3.2 KB	2024-02-02 18:09	✏️ 👁️
🔵os_windows.go	go	41.4 KB	2024-02-02 18:09	✏️ 👁️
🔵os_windows_arm.go	go	511 B	2024-02-02 18:09	✏️ 👁️
🔵os_windows_arm64.go	go	339 B	2024-02-02 18:09	✏️ 👁️
🔵pagetrace_off.go	go	550 B	2024-02-02 18:09	✏️ 👁️
🔵pagetrace_on.go	go	10.4 KB	2024-02-02 18:09	✏️ 👁️
🔵panic.go	go	41.8 KB	2024-02-02 18:09	✏️ 👁️
🔵panic32.go	go	4.8 KB	2024-02-02 18:09	✏️ 👁️
🔵panic_test.go	go	1.7 KB	2024-02-02 18:09	✏️ 👁️
🔵panicnil_test.go	go	1.3 KB	2024-02-02 18:09	✏️ 👁️
🔵pinner.go	go	11 KB	2024-02-02 18:09	✏️ 👁️
🔵pinner_test.go	go	11 KB	2024-02-02 18:09	✏️ 👁️
🔵plugin.go	go	4.4 KB	2024-02-02 18:09	✏️ 👁️
🔵preempt.go	go	15 KB	2024-02-02 18:09	✏️ 👁️
📄preempt_386.s	s	824 B	2024-02-02 18:09	✏️ 👁️
📄preempt_amd64.s	s	1.7 KB	2024-02-02 18:09	✏️ 👁️
📄preempt_arm.s	s	1.5 KB	2024-02-02 18:09	✏️ 👁️
📄preempt_arm64.s	s	2 KB	2024-02-02 18:09	✏️ 👁️
📄preempt_loong64.s	s	2.4 KB	2024-02-02 18:09	✏️ 👁️
📄preempt_mips64x.s	s	2.7 KB	2024-02-02 18:09	✏️ 👁️
📄preempt_mipsx.s	s	2.7 KB	2024-02-02 18:09	✏️ 👁️
🔵preempt_nonwindows.go	go	290 B	2024-02-02 18:09	✏️ 👁️
📄preempt_ppc64x.s	s	2.7 KB	2024-02-02 18:09	✏️ 👁️
📄preempt_riscv64.s	s	2.3 KB	2024-02-02 18:09	✏️ 👁️
📄preempt_s390x.s	s	1 KB	2024-02-02 18:09	✏️ 👁️
📄preempt_wasm.s	s	176 B	2024-02-02 18:09	✏️ 👁️
🔵print.go	go	5.9 KB	2024-02-02 18:09	✏️ 👁️
🔵proc.go	go	204.3 KB	2024-02-02 18:09	✏️ 👁️
🔵proc_runtime_test.go	go	1.4 KB	2024-02-02 18:09	✏️ 👁️
🔵proc_test.go	go	25.8 KB	2024-02-02 18:09	✏️ 👁️
🔵profbuf.go	go	18.3 KB	2024-02-02 18:09	✏️ 👁️
🔵profbuf_test.go	go	8.5 KB	2024-02-02 18:09	✏️ 👁️
🔵proflabel.go	go	1.5 KB	2024-02-02 18:09	✏️ 👁️
🔵race.go	go	18.8 KB	2024-02-02 18:09	✏️ 👁️
🔵race0.go	go	2.8 KB	2024-02-02 18:09	✏️ 👁️
📄race_amd64.s	s	13.9 KB	2024-02-02 18:09	✏️ 👁️
📄race_arm64.s	s	14.2 KB	2024-02-02 18:09	✏️ 👁️
📄race_ppc64le.s	s	15.9 KB	2024-02-02 18:09	✏️ 👁️
📄race_s390x.s	s	12 KB	2024-02-02 18:09	✏️ 👁️
🔵rand.go	go	7.1 KB	2024-02-02 18:09	✏️ 👁️
🔵rand_test.go	go	2 KB	2024-02-02 18:09	✏️ 👁️
🔵rdebug.go	go	550 B	2024-02-02 18:09	✏️ 👁️
🔵retry.go	go	760 B	2024-02-02 18:09	✏️ 👁️
📄rt0_aix_ppc64.s	s	4.1 KB	2024-02-02 18:09	✏️ 👁️
📄rt0_android_386.s	s	822 B	2024-02-02 18:09	✏️ 👁️
📄rt0_android_amd64.s	s	754 B	2024-02-02 18:09	✏️ 👁️
📄rt0_android_arm.s	s	843 B	2024-02-02 18:09	✏️ 👁️
📄rt0_android_arm64.s	s	941 B	2024-02-02 18:09	✏️ 👁️
📄rt0_darwin_amd64.s	s	399 B	2024-02-02 18:09	✏️ 👁️
📄rt0_darwin_arm64.s	s	1.7 KB	2024-02-02 18:09	✏️ 👁️
📄rt0_dragonfly_amd64.s	s	448 B	2024-02-02 18:09	✏️ 👁️
📄rt0_freebsd_386.s	s	454 B	2024-02-02 18:09	✏️ 👁️
📄rt0_freebsd_amd64.s	s	442 B	2024-02-02 18:09	✏️ 👁️
📄rt0_freebsd_arm.s	s	298 B	2024-02-02 18:09	✏️ 👁️
📄rt0_freebsd_arm64.s	s	1.9 KB	2024-02-02 18:09	✏️ 👁️
📄rt0_freebsd_riscv64.s	s	2.7 KB	2024-02-02 18:09	✏️ 👁️
📄rt0_illumos_amd64.s	s	311 B	2024-02-02 18:09	✏️ 👁️
📄rt0_ios_amd64.s	s	425 B	2024-02-02 18:09	✏️ 👁️
📄rt0_ios_arm64.s	s	425 B	2024-02-02 18:09	✏️ 👁️
📄rt0_js_wasm.s	s	1.5 KB	2024-02-02 18:09	✏️ 👁️
📄rt0_linux_386.s	s	450 B	2024-02-02 18:09	✏️ 👁️
📄rt0_linux_amd64.s	s	307 B	2024-02-02 18:09	✏️ 👁️
📄rt0_linux_arm.s	s	1007 B	2024-02-02 18:09	✏️ 👁️
📄rt0_linux_arm64.s	s	1.8 KB	2024-02-02 18:09	✏️ 👁️
📄rt0_linux_loong64.s	s	2 KB	2024-02-02 18:09	✏️ 👁️
📄rt0_linux_mips64x.s	s	1014 B	2024-02-02 18:09	✏️ 👁️
📄rt0_linux_mipsx.s	s	797 B	2024-02-02 18:09	✏️ 👁️
📄rt0_linux_ppc64.s	s	847 B	2024-02-02 18:09	✏️ 👁️
📄rt0_linux_ppc64le.s	s	2.9 KB	2024-02-02 18:09	✏️ 👁️
📄rt0_linux_riscv64.s	s	2.6 KB	2024-02-02 18:09	✏️ 👁️
📄rt0_linux_s390x.s	s	676 B	2024-02-02 18:09	✏️ 👁️
📄rt0_netbsd_386.s	s	452 B	2024-02-02 18:09	✏️ 👁️
📄rt0_netbsd_amd64.s	s	309 B	2024-02-02 18:09	✏️ 👁️
📄rt0_netbsd_arm.s	s	296 B	2024-02-02 18:09	✏️ 👁️
📄rt0_netbsd_arm64.s	s	1.8 KB	2024-02-02 18:09	✏️ 👁️
📄rt0_openbsd_386.s	s	454 B	2024-02-02 18:09	✏️ 👁️
📄rt0_openbsd_amd64.s	s	311 B	2024-02-02 18:09	✏️ 👁️
📄rt0_openbsd_arm.s	s	298 B	2024-02-02 18:09	✏️ 👁️
📄rt0_openbsd_arm64.s	s	2 KB	2024-02-02 18:09	✏️ 👁️
📄rt0_openbsd_mips64.s	s	976 B	2024-02-02 18:09	✏️ 👁️
📄rt0_openbsd_ppc64.s	s	370 B	2024-02-02 18:09	✏️ 👁️
📄rt0_openbsd_riscv64.s	s	372 B	2024-02-02 18:09	✏️ 👁️
📄rt0_plan9_386.s	s	523 B	2024-02-02 18:09	✏️ 👁️
📄rt0_plan9_amd64.s	s	481 B	2024-02-02 18:09	✏️ 👁️
📄rt0_plan9_arm.s	s	397 B	2024-02-02 18:09	✏️ 👁️
📄rt0_solaris_amd64.s	s	311 B	2024-02-02 18:09	✏️ 👁️
📄rt0_wasip1_wasm.s	s	387 B	2024-02-02 18:09	✏️ 👁️
📄rt0_windows_386.s	s	1.3 KB	2024-02-02 18:09	✏️ 👁️
📄rt0_windows_amd64.s	s	1.1 KB	2024-02-02 18:09	✏️ 👁️
📄rt0_windows_arm.s	s	386 B	2024-02-02 18:09	✏️ 👁️
📄rt0_windows_arm64.s	s	733 B	2024-02-02 18:09	✏️ 👁️
🐍runtime-gdb.py	py	15.4 KB	2024-02-02 18:09	✏️ 👁️
🔵runtime-gdb_test.go	go	24 KB	2024-02-02 18:09	✏️ 👁️
🔵runtime-gdb_unix_test.go	go	9.4 KB	2024-02-02 18:09	✏️ 👁️
🔵runtime-lldb_test.go	go	5 KB	2024-02-02 18:09	✏️ 👁️
🔵runtime-seh_windows_test.go	go	4.7 KB	2024-02-02 18:09	✏️ 👁️
🔵runtime.go	go	7.1 KB	2024-02-02 18:09	✏️ 👁️
🔵runtime1.go	go	16.7 KB	2024-02-02 18:09	✏️ 👁️
🔵runtime2.go	go	46.2 KB	2024-02-02 18:09	✏️ 👁️
🔵runtime_boring.go	go	606 B	2024-02-02 18:09	✏️ 👁️
🔵runtime_linux_test.go	go	1.8 KB	2024-02-02 18:09	✏️ 👁️
🔵runtime_mmap_test.go	go	1.8 KB	2024-02-02 18:09	✏️ 👁️
🔵runtime_test.go	go	11.8 KB	2024-02-02 18:09	✏️ 👁️
🔵runtime_unix_test.go	go	1.2 KB	2024-02-02 18:09	✏️ 👁️
🔵rwmutex.go	go	5 KB	2024-02-02 18:09	✏️ 👁️
🔵rwmutex_test.go	go	4.2 KB	2024-02-02 18:09	✏️ 👁️
🔵security_aix.go	go	449 B	2024-02-02 18:09	✏️ 👁️
🔵security_issetugid.go	go	502 B	2024-02-02 18:09	✏️ 👁️
🔵security_linux.go	go	335 B	2024-02-02 18:09	✏️ 👁️
🔵security_nonunix.go	go	256 B	2024-02-02 18:09	✏️ 👁️
🔵security_test.go	go	4.1 KB	2024-02-02 18:09	✏️ 👁️
🔵security_unix.go	go	818 B	2024-02-02 18:09	✏️ 👁️
🔵select.go	go	14.8 KB	2024-02-02 18:09	✏️ 👁️
🔵sema.go	go	18.4 KB	2024-02-02 18:09	✏️ 👁️
🔵sema_test.go	go	4.2 KB	2024-02-02 18:09	✏️ 👁️
🔵semasleep_test.go	go	3.5 KB	2024-02-02 18:09	✏️ 👁️
🔵sigaction.go	go	489 B	2024-02-02 18:09	✏️ 👁️
🔵signal_386.go	go	1.7 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_aix_ppc64.go	go	3.5 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_amd64.go	go	2.7 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_arm.go	go	2.5 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_arm64.go	go	3.8 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_darwin.go	go	2.1 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_darwin_amd64.go	go	4 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_darwin_arm64.go	go	3.6 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_dragonfly.go	go	2.2 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_dragonfly_amd64.go	go	2 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_freebsd.go	go	2.2 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_freebsd_386.go	go	1.6 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_freebsd_amd64.go	go	2 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_freebsd_arm.go	go	2.2 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_freebsd_arm64.go	go	3.2 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_freebsd_riscv64.go	go	3.1 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_linux_386.go	go	1.6 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_linux_amd64.go	go	2.1 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_linux_arm.go	go	2.1 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_linux_arm64.go	go	2.9 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_linux_loong64.go	go	3.2 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_linux_mips64x.go	go	3.3 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_linux_mipsx.go	go	3.7 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_linux_ppc64x.go	go	3.5 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_linux_riscv64.go	go	2.9 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_linux_s390x.go	go	4.5 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_loong64.go	go	3 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_mips64x.go	go	3.2 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_mipsx.go	go	3.1 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_netbsd.go	go	2.2 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_netbsd_386.go	go	1.8 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_netbsd_amd64.go	go	2.3 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_netbsd_arm.go	go	2.3 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_netbsd_arm64.go	go	3.4 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_openbsd.go	go	2.2 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_openbsd_386.go	go	1.6 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_openbsd_amd64.go	go	2 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_openbsd_arm.go	go	2.1 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_openbsd_arm64.go	go	3.4 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_openbsd_mips64.go	go	3.3 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_openbsd_ppc64.go	go	3.5 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_openbsd_riscv64.go	go	3.1 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_plan9.go	go	1.9 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_ppc64x.go	go	3.7 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_riscv64.go	go	2.9 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_solaris.go	go	4.5 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_solaris_amd64.go	go	2.5 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_unix.go	go	44.1 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_windows.go	go	14.5 KB	2024-02-02 18:09	✏️ 👁️
🔵signal_windows_test.go	go	9 KB	2024-02-02 18:09	✏️ 👁️
🔵sigqueue.go	go	7.6 KB	2024-02-02 18:09	✏️ 👁️
🔵sigqueue_note.go	go	648 B	2024-02-02 18:09	✏️ 👁️
🔵sigqueue_plan9.go	go	3.3 KB	2024-02-02 18:09	✏️ 👁️
🔵sigtab_aix.go	go	11.3 KB	2024-02-02 18:09	✏️ 👁️
🔵sigtab_linux_generic.go	go	3.5 KB	2024-02-02 18:09	✏️ 👁️
🔵sigtab_linux_mipsx.go	go	6 KB	2024-02-02 18:09	✏️ 👁️
🔵sizeclasses.go	go	9.2 KB	2024-02-02 18:09	✏️ 👁️
🔵sizeof_test.go	go	1003 B	2024-02-02 18:09	✏️ 👁️
🔵slice.go	go	11.2 KB	2024-02-02 18:09	✏️ 👁️
🔵slice_test.go	go	10.3 KB	2024-02-02 18:09	✏️ 👁️
🔵softfloat64.go	go	11.5 KB	2024-02-02 18:09	✏️ 👁️
🔵softfloat64_test.go	go	4 KB	2024-02-02 18:09	✏️ 👁️
🔵stack.go	go	40 KB	2024-02-02 18:09	✏️ 👁️
🔵stack_test.go	go	23.1 KB	2024-02-02 18:09	✏️ 👁️
🔵start_line_amd64_test.go	go	647 B	2024-02-02 18:09	✏️ 👁️
🔵start_line_test.go	go	2.6 KB	2024-02-02 18:09	✏️ 👁️
🔵stkframe.go	go	9.9 KB	2024-02-02 18:09	✏️ 👁️
🔵string.go	go	13.4 KB	2024-02-02 18:09	✏️ 👁️
🔵string_test.go	go	13.3 KB	2024-02-02 18:09	✏️ 👁️
🔵stubs.go	go	17.4 KB	2024-02-02 18:09	✏️ 👁️
🔵stubs2.go	go	1.1 KB	2024-02-02 18:09	✏️ 👁️
🔵stubs3.go	go	324 B	2024-02-02 18:09	✏️ 👁️
🔵stubs_386.go	go	708 B	2024-02-02 18:09	✏️ 👁️
🔵stubs_amd64.go	go	1.4 KB	2024-02-02 18:09	✏️ 👁️
🔵stubs_arm.go	go	689 B	2024-02-02 18:09	✏️ 👁️
🔵stubs_arm64.go	go	700 B	2024-02-02 18:09	✏️ 👁️
🔵stubs_linux.go	go	650 B	2024-02-02 18:09	✏️ 👁️
🔵stubs_loong64.go	go	638 B	2024-02-02 18:09	✏️ 👁️
🔵stubs_mips64x.go	go	522 B	2024-02-02 18:09	✏️ 👁️
🔵stubs_mipsx.go	go	441 B	2024-02-02 18:09	✏️ 👁️
🔵stubs_nonlinux.go	go	298 B	2024-02-02 18:09	✏️ 👁️
🔵stubs_ppc64.go	go	302 B	2024-02-02 18:09	✏️ 👁️
🔵stubs_ppc64x.go	go	688 B	2024-02-02 18:09	✏️ 👁️
🔵stubs_riscv64.go	go	695 B	2024-02-02 18:09	✏️ 👁️
🔵stubs_s390x.go	go	414 B	2024-02-02 18:09	✏️ 👁️
🔵symtab.go	go	34.8 KB	2024-02-02 18:09	✏️ 👁️
🔵symtab_test.go	go	7.5 KB	2024-02-02 18:09	✏️ 👁️
🔵symtabinl.go	go	3.8 KB	2024-02-02 18:09	✏️ 👁️
🔵symtabinl_test.go	go	3 KB	2024-02-02 18:09	✏️ 👁️
📄sys_aix_ppc64.s	s	7.4 KB	2024-02-02 18:09	✏️ 👁️
🔵sys_arm.go	go	521 B	2024-02-02 18:09	✏️ 👁️
🔵sys_arm64.go	go	469 B	2024-02-02 18:09	✏️ 👁️
🔵sys_darwin.go	go	22.6 KB	2024-02-02 18:09	✏️ 👁️
📄sys_darwin_amd64.s	s	19.7 KB	2024-02-02 18:09	✏️ 👁️
🔵sys_darwin_arm64.go	go	1.7 KB	2024-02-02 18:09	✏️ 👁️
📄sys_darwin_arm64.s	s	18.3 KB	2024-02-02 18:09	✏️ 👁️
📄sys_dragonfly_amd64.s	s	8.3 KB	2024-02-02 18:09	✏️ 👁️
📄sys_freebsd_386.s	s	9.4 KB	2024-02-02 18:09	✏️ 👁️
📄sys_freebsd_amd64.s	s	12.7 KB	2024-02-02 18:09	✏️ 👁️
📄sys_freebsd_arm.s	s	10.4 KB	2024-02-02 18:09	✏️ 👁️
📄sys_freebsd_arm64.s	s	9.5 KB	2024-02-02 18:09	✏️ 👁️
📄sys_freebsd_riscv64.s	s	8.9 KB	2024-02-02 18:09	✏️ 👁️
🔵sys_libc.go	go	1.8 KB	2024-02-02 18:09	✏️ 👁️
📄sys_linux_386.s	s	17.9 KB	2024-02-02 18:09	✏️ 👁️
📄sys_linux_amd64.s	s	15.7 KB	2024-02-02 18:09	✏️ 👁️
📄sys_linux_arm.s	s	13.5 KB	2024-02-02 18:09	✏️ 👁️
📄sys_linux_arm64.s	s	16.7 KB	2024-02-02 18:09	✏️ 👁️
📄sys_linux_loong64.s	s	14.2 KB	2024-02-02 18:09	✏️ 👁️
📄sys_linux_mips64x.s	s	12 KB	2024-02-02 18:09	✏️ 👁️
📄sys_linux_mipsx.s	s	9.7 KB	2024-02-02 18:09	✏️ 👁️
📄sys_linux_ppc64x.s	s	18.1 KB	2024-02-02 18:09	✏️ 👁️
📄sys_linux_riscv64.s	s	11.5 KB	2024-02-02 18:09	✏️ 👁️
📄sys_linux_s390x.s	s	12.5 KB	2024-02-02 18:09	✏️ 👁️
🔵sys_loong64.go	go	489 B	2024-02-02 18:09	✏️ 👁️
🔵sys_mips64x.go	go	500 B	2024-02-02 18:09	✏️ 👁️
🔵sys_mipsx.go	go	496 B	2024-02-02 18:09	✏️ 👁️
📄sys_netbsd_386.s	s	9.6 KB	2024-02-02 18:09	✏️ 👁️
📄sys_netbsd_amd64.s	s	9.8 KB	2024-02-02 18:09	✏️ 👁️
📄sys_netbsd_arm.s	s	10.6 KB	2024-02-02 18:09	✏️ 👁️
📄sys_netbsd_arm64.s	s	9.5 KB	2024-02-02 18:09	✏️ 👁️
🔵sys_nonppc64x.go	go	245 B	2024-02-02 18:09	✏️ 👁️
🔵sys_openbsd.go	go	2.6 KB	2024-02-02 18:09	✏️ 👁️
🔵sys_openbsd1.go	go	1.2 KB	2024-02-02 18:09	✏️ 👁️
🔵sys_openbsd2.go	go	8.7 KB	2024-02-02 18:09	✏️ 👁️
🔵sys_openbsd3.go	go	3.4 KB	2024-02-02 18:09	✏️ 👁️
📄sys_openbsd_386.s	s	20.4 KB	2024-02-02 18:09	✏️ 👁️
📄sys_openbsd_amd64.s	s	15.5 KB	2024-02-02 18:09	✏️ 👁️
📄sys_openbsd_arm.s	s	18.5 KB	2024-02-02 18:09	✏️ 👁️
📄sys_openbsd_arm64.s	s	15.1 KB	2024-02-02 18:09	✏️ 👁️
📄sys_openbsd_mips64.s	s	8.8 KB	2024-02-02 18:09	✏️ 👁️
📄sys_openbsd_ppc64.s	s	15.3 KB	2024-02-02 18:09	✏️ 👁️
📄sys_openbsd_riscv64.s	s	16.8 KB	2024-02-02 18:09	✏️ 👁️
📄sys_plan9_386.s	s	4.5 KB	2024-02-02 18:09	✏️ 👁️
📄sys_plan9_amd64.s	s	4.6 KB	2024-02-02 18:09	✏️ 👁️
📄sys_plan9_arm.s	s	7 KB	2024-02-02 18:09	✏️ 👁️
🔵sys_ppc64x.go	go	532 B	2024-02-02 18:09	✏️ 👁️
🔵sys_riscv64.go	go	469 B	2024-02-02 18:09	✏️ 👁️
🔵sys_s390x.go	go	469 B	2024-02-02 18:09	✏️ 👁️
📄sys_solaris_amd64.s	s	6.4 KB	2024-02-02 18:09	✏️ 👁️
🔵sys_wasm.go	go	758 B	2024-02-02 18:09	✏️ 👁️
📄sys_wasm.s	s	1.4 KB	2024-02-02 18:09	✏️ 👁️
📄sys_windows_386.s	s	6.5 KB	2024-02-02 18:09	✏️ 👁️
📄sys_windows_amd64.s	s	8.4 KB	2024-02-02 18:09	✏️ 👁️
📄sys_windows_arm.s	s	7.7 KB	2024-02-02 18:09	✏️ 👁️
📄sys_windows_arm64.s	s	6.8 KB	2024-02-02 18:09	✏️ 👁️
🔵sys_x86.go	go	552 B	2024-02-02 18:09	✏️ 👁️
🔵syscall2_solaris.go	go	1.8 KB	2024-02-02 18:09	✏️ 👁️
🔵syscall_aix.go	go	6.3 KB	2024-02-02 18:09	✏️ 👁️
🔵syscall_solaris.go	go	8.4 KB	2024-02-02 18:09	✏️ 👁️
🔵syscall_unix_test.go	go	635 B	2024-02-02 18:09	✏️ 👁️
🔵syscall_windows.go	go	16.6 KB	2024-02-02 18:09	✏️ 👁️
🔵syscall_windows_test.go	go	32.5 KB	2024-02-02 18:09	✏️ 👁️
🔵tagptr.go	go	496 B	2024-02-02 18:09	✏️ 👁️
🔵tagptr_32bit.go	go	927 B	2024-02-02 18:09	✏️ 👁️
🔵tagptr_64bit.go	go	3.2 KB	2024-02-02 18:09	✏️ 👁️
🔵test_amd64.go	go	196 B	2024-02-02 18:09	✏️ 👁️
📄test_amd64.s	s	316 B	2024-02-02 18:09	✏️ 👁️
🔵test_stubs.go	go	218 B	2024-02-02 18:09	✏️ 👁️
📄textflag.h	h	1.5 KB	2024-02-02 18:09	✏️ 👁️
🔵time.go	go	30.6 KB	2024-02-02 18:09	✏️ 👁️
🔵time_fake.go	go	2.5 KB	2024-02-02 18:09	✏️ 👁️
📄time_linux_amd64.s	s	2 KB	2024-02-02 18:09	✏️ 👁️
🔵time_nofake.go	go	709 B	2024-02-02 18:09	✏️ 👁️
🔵time_test.go	go	2 KB	2024-02-02 18:09	✏️ 👁️
📄time_windows.h	h	753 B	2024-02-02 18:09	✏️ 👁️
📄time_windows_386.s	s	1.7 KB	2024-02-02 18:09	✏️ 👁️
📄time_windows_amd64.s	s	786 B	2024-02-02 18:09	✏️ 👁️
📄time_windows_arm.s	s	2 KB	2024-02-02 18:09	✏️ 👁️
📄time_windows_arm64.s	s	906 B	2024-02-02 18:09	✏️ 👁️
🔵timeasm.go	go	418 B	2024-02-02 18:09	✏️ 👁️
🔵timestub.go	go	532 B	2024-02-02 18:09	✏️ 👁️
🔵timestub2.go	go	363 B	2024-02-02 18:09	✏️ 👁️
📄tls_arm.s	s	3.5 KB	2024-02-02 18:09	✏️ 👁️
📄tls_arm64.h	h	1.1 KB	2024-02-02 18:09	✏️ 👁️
📄tls_arm64.s	s	1.2 KB	2024-02-02 18:09	✏️ 👁️
📄tls_loong64.s	s	589 B	2024-02-02 18:09	✏️ 👁️
📄tls_mips64x.s	s	733 B	2024-02-02 18:09	✏️ 👁️
📄tls_mipsx.s	s	710 B	2024-02-02 18:09	✏️ 👁️
📄tls_ppc64x.s	s	1.5 KB	2024-02-02 18:09	✏️ 👁️
📄tls_riscv64.s	s	615 B	2024-02-02 18:09	✏️ 👁️
📄tls_s390x.s	s	1.5 KB	2024-02-02 18:09	✏️ 👁️
🔵tls_stub.go	go	260 B	2024-02-02 18:09	✏️ 👁️
🔵tls_windows_amd64.go	go	294 B	2024-02-02 18:09	✏️ 👁️
🔵trace.go	go	62.8 KB	2024-02-02 18:09	✏️ 👁️
🔵trace2.go	go	33.8 KB	2024-02-02 18:09	✏️ 👁️
🔵trace2buf.go	go	6.6 KB	2024-02-02 18:09	✏️ 👁️
🔵trace2cpu.go	go	8.9 KB	2024-02-02 18:09	✏️ 👁️
🔵trace2event.go	go	8.4 KB	2024-02-02 18:09	✏️ 👁️
🔵trace2map.go	go	4.4 KB	2024-02-02 18:09	✏️ 👁️
🔵trace2region.go	go	1.7 KB	2024-02-02 18:09	✏️ 👁️
🔵trace2runtime.go	go	24.2 KB	2024-02-02 18:09	✏️ 👁️
🔵trace2stack.go	go	9.5 KB	2024-02-02 18:09	✏️ 👁️
🔵trace2status.go	go	7.2 KB	2024-02-02 18:09	✏️ 👁️
🔵trace2string.go	go	2.6 KB	2024-02-02 18:09	✏️ 👁️
🔵trace2time.go	go	3.2 KB	2024-02-02 18:09	✏️ 👁️
🔵trace_cgo_test.go	go	4.5 KB	2024-02-02 18:09	✏️ 👁️
🔵traceback.go	go	54.6 KB	2024-02-02 18:09	✏️ 👁️
🔵traceback_test.go	go	22.9 KB	2024-02-02 18:09	✏️ 👁️
🔵tracebackx_test.go	go	509 B	2024-02-02 18:09	✏️ 👁️
🔵type.go	go	12.1 KB	2024-02-02 18:09	✏️ 👁️
🔵typekind.go	go	743 B	2024-02-02 18:09	✏️ 👁️
🔵unsafe.go	go	3 KB	2024-02-02 18:09	✏️ 👁️
🔵unsafepoint_test.go	go	3.3 KB	2024-02-02 18:09	✏️ 👁️
🔵utf8.go	go	3.4 KB	2024-02-02 18:09	✏️ 👁️
🔵vdso_elf32.go	go	2.8 KB	2024-02-02 18:09	✏️ 👁️
🔵vdso_elf64.go	go	2.8 KB	2024-02-02 18:09	✏️ 👁️
🔵vdso_freebsd.go	go	2.4 KB	2024-02-02 18:09	✏️ 👁️
🔵vdso_freebsd_arm.go	go	454 B	2024-02-02 18:09	✏️ 👁️
🔵vdso_freebsd_arm64.go	go	454 B	2024-02-02 18:09	✏️ 👁️
🔵vdso_freebsd_riscv64.go	go	429 B	2024-02-02 18:09	✏️ 👁️
🔵vdso_freebsd_x86.go	go	1.9 KB	2024-02-02 18:09	✏️ 👁️
🔵vdso_in_none.go	go	443 B	2024-02-02 18:09	✏️ 👁️
🔵vdso_linux.go	go	7.8 KB	2024-02-02 18:09	✏️ 👁️
🔵vdso_linux_386.go	go	669 B	2024-02-02 18:09	✏️ 👁️
🔵vdso_linux_amd64.go	go	685 B	2024-02-02 18:09	✏️ 👁️
🔵vdso_linux_arm.go	go	669 B	2024-02-02 18:09	✏️ 👁️
🔵vdso_linux_arm64.go	go	670 B	2024-02-02 18:09	✏️ 👁️
🔵vdso_linux_loong64.go	go	793 B	2024-02-02 18:09	✏️ 👁️
🔵vdso_linux_mips64x.go	go	850 B	2024-02-02 18:09	✏️ 👁️
🔵vdso_linux_ppc64x.go	go	672 B	2024-02-02 18:09	✏️ 👁️
🔵vdso_linux_riscv64.go	go	666 B	2024-02-02 18:09	✏️ 👁️
🔵vdso_linux_s390x.go	go	659 B	2024-02-02 18:09	✏️ 👁️
🔵vdso_test.go	go	3.7 KB	2024-02-02 18:09	✏️ 👁️
📄vlop_386.s	s	2 KB	2024-02-02 18:09	✏️ 👁️
📄vlop_arm.s	s	7.1 KB	2024-02-02 18:09	✏️ 👁️
🔵vlop_arm_test.go	go	3.7 KB	2024-02-02 18:09	✏️ 👁️
🔵vlrt.go	go	6.7 KB	2024-02-02 18:09	✏️ 👁️
🔵wincallback.go	go	3.5 KB	2024-02-02 18:09	✏️ 👁️
🔵write_err.go	go	291 B	2024-02-02 18:09	✏️ 👁️
🔵write_err_android.go	go	4.6 KB	2024-02-02 18:09	✏️ 👁️
🔵zcallback_windows.go	go	155 B	2024-02-02 18:09	✏️ 👁️
📄zcallback_windows.s	s	63.1 KB	2024-02-02 18:09	✏️ 👁️
📄zcallback_windows_arm.s	s	89.3 KB	2024-02-02 18:09	✏️ 👁️
📄zcallback_windows_arm64.s	s	89.3 KB	2024-02-02 18:09	✏️ 👁️

✏️ Rename