type ZeroRegion … // mightBeHeapPointer reports whether v might point to the heap. // v must have pointer type. func mightBeHeapPointer(v *Value) bool { … } // mightContainHeapPointer reports whether the data currently at addresses // [ptr,ptr+size) might contain heap pointers. "currently" means at memory state mem. // zeroes contains ZeroRegion data to help make that decision (see computeZeroMap). func mightContainHeapPointer(ptr *Value, size int64, mem *Value, zeroes map[ID]ZeroRegion) bool { … } // needwb reports whether we need write barrier for store op v. // v must be Store/Move/Zero. // zeroes provides known zero information (keyed by ID of memory-type values). func needwb(v *Value, zeroes map[ID]ZeroRegion) bool { … } // needWBsrc reports whether GC needs to see v when it is the source of a store. func needWBsrc(v *Value) bool { … } // needWBdst reports whether GC needs to see what used to be in *ptr when ptr is // the target of a pointer store. func needWBdst(ptr, mem *Value, zeroes map[ID]ZeroRegion) bool { … } // writebarrier pass inserts write barriers for store ops (Store, Move, Zero) // when necessary (the condition above). It rewrites store ops to branches // and runtime calls, like // // if writeBarrier.enabled { // buf := gcWriteBarrier2() // Not a regular Go call // buf[0] = val // buf[1] = *ptr // } // *ptr = val // // A sequence of WB stores for many pointer fields of a single type will // be emitted together, with a single branch. func writebarrier(f *Func) { … } // computeZeroMap returns a map from an ID of a memory value to // a set of locations that are known to be zeroed at that memory value. func (f *Func) computeZeroMap(select1 []*Value) map[ID]ZeroRegion { … } // wbcall emits write barrier runtime call in b, returns memory. func wbcall(pos src.XPos, b *Block, fn *obj.LSym, sp, mem *Value, args ...*Value) *Value { … } // round to a multiple of r, r is a power of 2. func round(o int64, r int64) int64 { … } // IsStackAddr reports whether v is known to be an address of a stack slot. func IsStackAddr(v *Value) bool { … } // IsGlobalAddr reports whether v is known to be an address of a global (or nil). func IsGlobalAddr(v *Value) bool { … } // IsReadOnlyGlobalAddr reports whether v is known to be an address of a read-only global. func IsReadOnlyGlobalAddr(v *Value) bool { … } // IsNewObject reports whether v is a pointer to a freshly allocated & zeroed object, // if so, also returns the memory state mem at which v is zero. func IsNewObject(v *Value, select1 []*Value) (mem *Value, ok bool) { … } // IsSanitizerSafeAddr reports whether v is known to be an address // that doesn't need instrumentation. func IsSanitizerSafeAddr(v *Value) bool { … } // isVolatile reports whether v is a pointer to argument region on stack which // will be clobbered by a function call. func isVolatile(v *Value) bool { … }
Codebase Browser
go