go/usr/austin/ogle/rruntime.go

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

import (
	"eval";
	"ptrace";
	"reflect";
)

// This file contains remote runtime definitions.  Using reflection,
// we convert all of these to interpreter types and layout their
// remote representations using the architecture rules.
//
// We could get most of these definitions from our own runtime
// package; however, some of them differ in convenient ways, some of
// them are not defined or exported by the runtime, and having our own
// definitions makes it easy to support multiple remote runtime
// versions.  This may turn out to be overkill.
//
// All of these structures are prefixed with rt1 to indicate the
// runtime version and to mark them as types used only as templates
// for remote types.

/*
 * Runtime data headers
 *
 * See $GOROOT/src/pkg/runtime/runtime.h
 */

type rt1String struct {
	str uintptr;
	len int;
}

type rt1Slice struct {
	array uintptr;
	len int;
	cap int;
}

type rt1Eface struct {
	typ uintptr;
	ptr uintptr;
}

/*
 * Runtime type structures
 *
 * See $GOROOT/src/pkg/runtime/type.h and $GOROOT/src/pkg/runtime/type.go
 */

type rt1UncommonType struct {
	name *string;
	pkgPath *string;
	//methods []method;
}

type rt1CommonType struct {
	size uintptr;
	hash uint32;
	alg, align, fieldAlign uint8;
	string *string;
	uncommonType *rt1UncommonType;
}

type rt1Type struct {
	// While Type is technically an Eface, treating the
	// discriminator as an opaque pointer and taking advantage of
	// the commonType prologue on all Type's makes type parsing
	// much simpler.
	typ uintptr;
	ptr *rt1CommonType;
}

type rt1StructField struct {
	name *string;
	pkgPath *string;
	typ *rt1Type;
	tag *string;
	offset uintptr;
}

type rt1StructType struct {
	rt1CommonType;
	fields []rt1StructField;
}

type rt1PtrType struct {
	rt1CommonType;
	elem *rt1Type;
}

type rt1SliceType struct {
	rt1CommonType;
	elem *rt1Type;
}

type rt1ArrayType struct {
	rt1CommonType;
	elem *rt1Type;
	len uintptr;
}

/*
 * Runtime scheduler structures
 *
 * See $GOROOT/src/pkg/runtime/runtime.h
 */

type rt1Stktop struct {
	stackguard uintptr;
	stackbase *rt1Stktop;
	gobuf rt1Gobuf;
}

type rt1Gobuf struct {
	sp uintptr;
	pc uintptr;
	g *rt1G;
}

type rt1G struct {
	stackguard uintptr;
	stackbase *rt1Stktop;
}

// runtimeIndexes stores the indexes of fields in the runtime
// structures.  It is filled in using reflection, so the name of the
// fields must match the names of the remoteType's in runtimeValues
// exactly and the names of the index fields must be the capitalized
// version of the names of the fields in the runtime structures above.
type runtimeIndexes struct {
	String struct {
		Str, Len int;
	};
	Slice struct {
		Array, Len, Cap int;
	};
	Eface struct {
		Typ, Ptr int;
	};

	UncommonType struct {
		Name, PkgPath int;
	};
	CommonType struct {
		Size, Hash, Alg, Align, FieldAlign, String, UncommonType int;
	};
	Type struct {
		Typ, Ptr int;
	};
	StructField struct {
		Name, PkgPath, Typ, Tag, Offset int;
	};
	StructType struct {
		Fields int;
	};
	PtrType struct {
		Elem int;
	};
	SliceType struct {
		Elem int;
	};
	ArrayType struct {
		Elem, Len int;
	};

	Stktop struct {
		Stackguard, Stackbase, Gobuf int;
	};
	Gobuf struct {
		Sp, Pc, G int;
	};
	G struct {
		Stackguard, Stackbase int;
	};
}

// runtimeValues stores the types and values that correspond to those
// in the remote runtime package.
type runtimeValues struct {
	// Runtime data headers
	String, Slice, Eface *remoteType;
	// Runtime type structures
	Type, CommonType, UncommonType, StructField, StructType, PtrType,
	ArrayType, SliceType *remoteType;
	// Runtime scheduler structures
	Stktop, Gobuf, G *remoteType;
	// Addresses of *runtime.XType types.  These are the
	// discriminators on the runtime.Type interface.  We use local
	// reflection to fill these in from the remote symbol table,
	// so the names must match the runtime names.
	PBoolType,
	PUint8Type, PUint16Type, PUint32Type, PUint64Type, PUintType, PUintptrType,
	PInt8Type, PInt16Type, PInt32Type, PInt64Type, PIntType,
	PFloat32Type, PFloat64Type, PFloatType,
	PArrayType, PStringType, PStructType, PPtrType, PFuncType,
	PInterfaceType, PSliceType, PMapType, PChanType,
	PDotDotDotType, PUnsafePointerType ptrace.Word;
}

// fillRuntimeIndexes fills a runtimeIndexes structure will the field
// indexes gathered from the remoteTypes recorded in a runtimeValues
// structure.
func fillRuntimeIndexes(runtime *runtimeValues, out *runtimeIndexes) {
	outv := reflect.Indirect(reflect.NewValue(out)).(*reflect.StructValue);
	outt := outv.Type().(*reflect.StructType);
	runtimev := reflect.Indirect(reflect.NewValue(runtime)).(*reflect.StructValue);

	// out contains fields corresponding to each runtime type
	for i := 0; i < outt.NumField(); i++ {
		// Find the interpreter type for this runtime type
		name := outt.Field(i).Name;
		et := runtimev.FieldByName(name).Interface().(*remoteType).Type.(*eval.StructType);

		// Get the field indexes of the interpreter struct type
		indexes := make(map[string] int, len(et.Elems));
		for j, f := range et.Elems {
			if f.Anonymous {
				continue;
			}
			name := f.Name;
			if name[0] >= 'a' && name[0] <= 'z' {
				name = string(name[0] + 'A' - 'a') + name[1:len(name)];
			}
			indexes[name] = j;
		}

		// Fill this field of out
		outStructv := outv.Field(i).(*reflect.StructValue);
		outStructt := outStructv.Type().(*reflect.StructType);
		for j := 0; j < outStructt.NumField(); j++ {
			f := outStructv.Field(j).(*reflect.IntValue);
			name := outStructt.Field(j).Name;
			f.Set(indexes[name]);
		}
	}
}