88 lines
3.5 KiB
C
88 lines
3.5 KiB
C
// Copyright 2012 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.
|
|
|
|
// Garbage collector (GC)
|
|
|
|
// GC instruction opcodes.
|
|
//
|
|
// The opcode of an instruction is followed by zero or more
|
|
// arguments to the instruction.
|
|
//
|
|
// Meaning of arguments:
|
|
// off Offset (in bytes) from the start of the current object
|
|
// objgc Pointer to GC info of an object
|
|
// objgcrel Offset to GC info of an object
|
|
// len Length of an array
|
|
// elemsize Size (in bytes) of an element
|
|
// size Size (in bytes)
|
|
//
|
|
// NOTE: There is a copy of these in ../reflect/type.go.
|
|
// They must be kept in sync.
|
|
enum {
|
|
GC_END, // End of object, loop or subroutine. Args: none
|
|
GC_PTR, // A typed pointer. Args: (off, objgc)
|
|
GC_APTR, // Pointer to an arbitrary object. Args: (off)
|
|
GC_ARRAY_START, // Start an array with a fixed length. Args: (off, len, elemsize)
|
|
GC_ARRAY_NEXT, // The next element of an array. Args: none
|
|
GC_CALL, // Call a subroutine. Args: (off, objgcrel)
|
|
GC_CHAN_PTR, // Go channel. Args: (off, ChanType*)
|
|
GC_STRING, // Go string. Args: (off)
|
|
GC_EFACE, // interface{}. Args: (off)
|
|
GC_IFACE, // interface{...}. Args: (off)
|
|
GC_SLICE, // Go slice. Args: (off, objgc)
|
|
GC_REGION, // A region/part of the current object. Args: (off, size, objgc)
|
|
|
|
GC_NUM_INSTR, // Number of instruction opcodes
|
|
};
|
|
|
|
enum {
|
|
// Size of GC's fixed stack.
|
|
//
|
|
// The current GC implementation permits:
|
|
// - at most 1 stack allocation because of GC_CALL
|
|
// - at most GC_STACK_CAPACITY allocations because of GC_ARRAY_START
|
|
GC_STACK_CAPACITY = 8,
|
|
};
|
|
|
|
enum {
|
|
ScanStackByFrames = 1,
|
|
IgnorePreciseGC = 0,
|
|
|
|
// Four bits per word (see #defines below).
|
|
wordsPerBitmapWord = sizeof(void*)*8/4,
|
|
bitShift = sizeof(void*)*8/4,
|
|
};
|
|
|
|
// Bits in per-word bitmap.
|
|
// #defines because enum might not be able to hold the values.
|
|
//
|
|
// Each word in the bitmap describes wordsPerBitmapWord words
|
|
// of heap memory. There are 4 bitmap bits dedicated to each heap word,
|
|
// so on a 64-bit system there is one bitmap word per 16 heap words.
|
|
// The bits in the word are packed together by type first, then by
|
|
// heap location, so each 64-bit bitmap word consists of, from top to bottom,
|
|
// the 16 bitMarked bits for the corresponding heap words,
|
|
// then the 16 bitScan/bitBlockBoundary bits, then the 16 bitAllocated bits.
|
|
// This layout makes it easier to iterate over the bits of a given type.
|
|
//
|
|
// The bitmap starts at mheap.arena_start and extends *backward* from
|
|
// there. On a 64-bit system the off'th word in the arena is tracked by
|
|
// the off/16+1'th word before mheap.arena_start. (On a 32-bit system,
|
|
// the only difference is that the divisor is 8.)
|
|
//
|
|
// To pull out the bits corresponding to a given pointer p, we use:
|
|
//
|
|
// off = p - (uintptr*)mheap.arena_start; // word offset
|
|
// b = (uintptr*)mheap.arena_start - off/wordsPerBitmapWord - 1;
|
|
// shift = off % wordsPerBitmapWord
|
|
// bits = *b >> shift;
|
|
// /* then test bits & bitAllocated, bits & bitMarked, etc. */
|
|
//
|
|
#define bitAllocated ((uintptr)1<<(bitShift*0)) /* block start; eligible for garbage collection */
|
|
#define bitScan ((uintptr)1<<(bitShift*1)) /* when bitAllocated is set */
|
|
#define bitMarked ((uintptr)1<<(bitShift*2)) /* when bitAllocated is set */
|
|
#define bitBlockBoundary ((uintptr)1<<(bitShift*1)) /* when bitAllocated is NOT set - mark for FlagNoGC objects */
|
|
|
|
#define bitMask (bitAllocated | bitScan | bitMarked)
|