src/runtime/type.h

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

// Runtime type representation.

typedef struct Type Type;
typedef struct UncommonType UncommonType;
typedef struct InterfaceType InterfaceType;
typedef struct Method Method;
typedef struct IMethod IMethod;
typedef struct SliceType SliceType;
typedef struct FuncType FuncType;

// Needs to be in sync with ../../cmd/ld/decodesym.c:/^commonsize and pkg/reflect/type.go:/type.
struct Type
{
	uintptr size;
	uint32 hash;
	uint8 _unused;
	uint8 align;
	uint8 fieldAlign;
	uint8 kind;
	void* alg;
	// gc stores type info required for garbage collector.
	// If (kind&KindGCProg)==0, then gc[0] points at sparse GC bitmap
	// (no indirection), 4 bits per word.
	// If (kind&KindGCProg)!=0, then gc[1] points to a compiler-generated
	// read-only GC program; and gc[0] points to BSS space for sparse GC bitmap.
	// For huge types (>MaxGCMask), runtime unrolls the program directly into
	// GC bitmap and gc[0] is not used. For moderately-sized types, runtime
	// unrolls the program into gc[0] space on first use. The first byte of gc[0]
	// (gc[0][0]) contains 'unroll' flag saying whether the program is already
	// unrolled into gc[0] or not.
	uintptr gc[2];
	String *string;
	UncommonType *x;
	Type *ptrto;
	byte *zero;  // ptr to the zero value for this type
};

struct Method
{
	String *name;
	String *pkgPath;
	Type	*mtyp;
	Type *typ;
	void (*ifn)(void);
	void (*tfn)(void);
};

struct UncommonType
{
	String *name;
	String *pkgPath;
	Slice mhdr;
	Method m[];
};

struct IMethod
{
	String *name;
	String *pkgPath;
	Type *type;
};

struct InterfaceType
{
	Type  typ;
	Slice mhdr;
	IMethod m[];
};

struct MapType
{
	Type typ;
	Type *key;
	Type *elem;
	Type *bucket;		// internal type representing a hash bucket
	Type *hmap;		// internal type representing a Hmap
	uint8 keysize;		// size of key slot
	bool indirectkey;	// store ptr to key instead of key itself
	uint8 valuesize;	// size of value slot
	bool indirectvalue;	// store ptr to value instead of value itself
	uint16 bucketsize;	// size of bucket
};

struct ChanType
{
	Type typ;
	Type *elem;
	uintptr dir;
};

struct SliceType
{
	Type typ;
	Type *elem;
};

struct FuncType
{
	Type typ;
	bool dotdotdot;
	Slice in;
	Slice out;
};

struct PtrType
{
	Type typ;
	Type *elem;
};