Convert runtime regions to use full-fledged Type structures

instead of hacky types-as-strings.

Reorg the passes a bit so there aren't so many runtime-specific
data structures.

Author: randall77

core/read.go

@@ -77,7 +77,7 @@ func (p *Process) readCore(core *os.File) error {
 		return err
 	}
 	if e.Type != elf.ET_CORE {
-		return fmt.Errorf("%s is not a core file", core)
+		return fmt.Errorf("%s is not a core file", core.Name())
 	}
 	switch e.Class {
 	case elf.ELFCLASS32:

gocore/dwarf.go

@@ -15,6 +15,7 @@ func (p *Program) readDWARFTypes() {
 
 	// Make one of our own Types for each dwarf type.
 	r := d.Reader()
+	var types []*Type
 	for e, err := r.Next(); e != nil && err == nil; e, err = r.Next() {
 		switch e.Tag {
 		case dwarf.TagArrayType, dwarf.TagPointerType, dwarf.TagStructType, dwarf.TagBaseType, dwarf.TagSubroutineType, dwarf.TagTypedef:
@@ -27,8 +28,8 @@ func (p *Program) readDWARFTypes() {
 				size = dwarfSize(dt, p.proc.PtrSize())
 			}
 			t := &Type{name: gocoreName(dt), Size: size}
-			p.types = append(p.types, t)
 			p.dwarfMap[dt] = t
+			types = append(types, t)
 		}
 	}
 
@@ -71,7 +72,7 @@ func (p *Program) readDWARFTypes() {
 	}
 
 	// Detect strings & slices
-	for _, t := range p.types {
+	for _, t := range types {
 		if t.Kind != KindStruct {
 			continue
 		}
@@ -132,6 +133,13 @@ func (p *Program) readDWARFTypes() {
 			t.Fields = nil
 		}
 	}
+
+	// Make a runtime name -> Type map for existing DWARF types.
+	p.runtimeNameMap = map[string][]*Type{}
+	for dt, t := range p.dwarfMap {
+		name := runtimeName(dt)
+		p.runtimeNameMap[name] = append(p.runtimeNameMap[name], t)
+	}
 }
 
 // dwarfSize is used to compute the size of a DWARF type when .Size()
@@ -456,12 +464,12 @@ func (p *Program) typeObject(a core.Address, t *Type, r reader, add func(core.Ad
 		}
 		ptr := r.ReadPtr(a.Add(ptrSize))
 		if t.Kind == KindIface {
-			typ = p.proc.ReadPtr(typ.Add(p.rtStructs["runtime.itab"].fields["_type"].off))
+			typ = p.proc.ReadPtr(typ.Add(p.findType("runtime.itab").field("_type").Off))
 		}
 		// TODO: for KindEface, type the typ pointer. It might point to the heap
 		// if the type was allocated with reflect.
 
-		direct := p.proc.ReadUint8(typ.Add(p.rtStructs["runtime._type"].fields["kind"].off))&uint8(p.rtConstants["kindDirectIface"]) != 0
+		direct := p.proc.ReadUint8(typ.Add(p.findType("runtime._type").field("kind").Off))&uint8(p.rtConstants["kindDirectIface"]) != 0
 		dt := p.runtimeType2Type(typ)
 		if direct {
 			// Find the base type of the pointer held in the interface.
@@ -514,7 +522,6 @@ func (p *Program) typeObject(a core.Address, t *Type, r reader, add func(core.Ad
 		ft := f.closure
 		if ft == nil {
 			ft = &Type{name: "closure for " + f.name, Size: ptrSize, Kind: KindPtr}
-			p.types = append(p.types, ft)
 			// For now, treat a closure like an unsafe.Pointer.
 			// TODO: better value for size?
 			f.closure = ft
@@ -553,27 +560,8 @@ func (p *Program) typeObject(a core.Address, t *Type, r reader, add func(core.Ad
 	}
 }
 
-// findRuntimeInfo uses DWARF information to find all the struct sizes,
-// field offsets, and field types for runtime data structures.
-// It also finds a useful set of runtime constants.
-// It populates p.rtStructs and rtConstants.
-func (p *Program) findRuntimeInfo() {
-	p.rtStructs = map[string]structInfo{}
-	for dt, _ := range p.dwarfMap {
-		rtname := runtimeName(dt)
-		if !strings.HasPrefix(rtname, "runtime.") {
-			continue
-		}
-		x, ok := dt.(*dwarf.StructType)
-		if !ok {
-			continue
-		}
-		s := structInfo{size: dt.Size(), fields: map[string]fieldInfo{}}
-		for _, f := range x.Field {
-			s.fields[f.Name] = fieldInfo{off: f.ByteOffset, typ: runtimeName(f.Type)}
-		}
-		p.rtStructs[rtname] = s
-	}
+// readRuntimeConstants populates the p.rtConstants map.
+func (p *Program) readRuntimeConstants() {
 	p.rtConstants = map[string]int64{}
 	// TODO: It would be ideal if we could glean this info from DWARF.
 	// But we don't package up constants in DWARF right now. See issue #14517.
@@ -600,23 +588,22 @@ func (p *Program) findRuntimeInfo() {
 	m["_PageSize"] = 1 << 13
 }
 
-func (p *Program) findRoots() {
-	const (
-		DW_OP_addr           = 0x03
-		DW_OP_call_frame_cfa = 0x9c
-		DW_OP_plus           = 0x22
-		DW_OP_consts         = 0x11
-	)
-	d, _ := p.proc.DWARF()
+const (
+	_DW_OP_addr           = 0x03
+	_DW_OP_call_frame_cfa = 0x9c
+	_DW_OP_plus           = 0x22
+	_DW_OP_consts         = 0x11
+)
 
-	// Find global variables.
+func (p *Program) readGlobals() {
+	d, _ := p.proc.DWARF()
 	r := d.Reader()
 	for e, err := r.Next(); e != nil && err == nil; e, err = r.Next() {
 		if e.Tag != dwarf.TagVariable {
 			continue
 		}
 		loc := e.AttrField(dwarf.AttrLocation).Val.([]byte)
-		if loc[0] != DW_OP_addr {
+		if loc[0] != _DW_OP_addr {
 			continue
 		}
 		var a core.Address
@@ -644,16 +631,18 @@ func (p *Program) findRoots() {
 			Live: nil,
 		})
 	}
+}
 
-	// Find stack variables.
+func (p *Program) readStackVars() {
 	type Var struct {
 		name string
 		off  int64
 		typ  *Type
 	}
 	vars := map[*Func][]Var{}
 	var curfn *Func
-	r = d.Reader()
+	d, _ := p.proc.DWARF()
+	r := d.Reader()
 	for e, err := r.Next(); e != nil && err == nil; e, err = r.Next() {
 		if e.Tag == dwarf.TagSubprogram {
 			min := core.Address(e.AttrField(dwarf.AttrLowpc).Val.(uint64))
@@ -681,14 +670,14 @@ func (p *Program) findRoots() {
 			continue
 		}
 		loc := aloc.Val.([]byte)
-		if len(loc) == 0 || loc[0] != DW_OP_call_frame_cfa {
+		if len(loc) == 0 || loc[0] != _DW_OP_call_frame_cfa {
 			continue
 		}
 		loc = loc[1:]
 		var off int64
-		if len(loc) != 0 && loc[len(loc)-1] == DW_OP_plus {
+		if len(loc) != 0 && loc[len(loc)-1] == _DW_OP_plus {
 			loc = loc[:len(loc)-1]
-			if len(loc) == 0 || loc[0] != DW_OP_consts {
+			if len(loc) == 0 || loc[0] != _DW_OP_consts {
 				continue
 			}
 			loc = loc[1:]
@@ -748,7 +737,7 @@ func (p *Program) findRoots() {
 				r := &Root{
 					Name: "unk",
 					Addr: a,
-					Type: p.runtimeNameMap["unsafe.Pointer"][0],
+					Type: p.findType("unsafe.Pointer"),
 					Live: f.live,
 				}
 				f.roots = append(f.roots, r)

gocore/parse.go

@@ -3,26 +3,13 @@ package gocore
 import (
 	"debug/dwarf"
 	"fmt"
+	"strings"
 
 	"github.com/randall77/corelib/core"
 )
 
 // Core takes a loaded core file and extracts Go information from it.
 func Core(proc *core.Process) (p *Program, err error) {
-	// Check symbol table to make sure we know the addresses
-	// of some critical runtime data structures.
-	m, err := proc.Symbols()
-	if err != nil {
-		return nil, err
-	}
-	for _, s := range rtSymbols {
-		if m["runtime."+s.name] == 0 {
-			// We're missing some address that we need.
-			return nil, fmt.Errorf("can't find runtime data structure %s. Is the binary unstripped?", s.name)
-		}
-	}
-	// TODO: is the symbol table redundant with the DWARF info? Could we just use DWARF?
-
 	// Make sure we have DWARF info.
 	if _, err := proc.DWARF(); err != nil {
 		return nil, err
@@ -50,51 +37,34 @@ func Core(proc *core.Process) (p *Program, err error) {
 		dwarfMap:   map[dwarf.Type]*Type{},
 	}
 
-	// Load the build version.
-	a := m["runtime.buildVersion"]
-	ptr := proc.ReadPtr(a)
-	len := proc.ReadInt(a.Add(proc.PtrSize()))
-	b := make([]byte, len)
-	proc.ReadAt(b, ptr)
-	p.buildVersion = string(b)
-
-	// Initialize runtime regions.
-	p.runtime = map[string]region{}
-	for _, s := range rtSymbols {
-		p.runtime[s.name] = region{p: p, a: m["runtime."+s.name], typ: s.typ}
+	// Initialize everything that just depends on DWARF.
+	p.readDWARFTypes()
+	p.readRuntimeConstants()
+	p.readGlobals()
+
+	// Find runtime globals we care about. Initialize regions for them.
+	p.rtGlobals = map[string]region{}
+	for _, g := range p.globals {
+		if strings.HasPrefix(g.Name, "runtime.") {
+			p.rtGlobals[g.Name[8:]] = region{p: p, a: g.Addr, typ: g.Type}
+		}
 	}
 
-	p.readDWARFTypes()
-	p.findRuntimeInfo()
+	// Read all the data that depends on runtime globals.
+	p.buildVersion = p.rtGlobals["buildVersion"].String()
 	p.readModules()
+	p.readStackVars()
 	p.readSpans()
 	p.readMs()
 	p.readGs()
-	p.findRoots()
 	p.readObjects()
 	p.typeHeap()
-	return
-}
 
-// rtSymbols is a list of all the runtime globals that we need to access,
-// together with their types.
-var rtSymbols = [...]struct {
-	name, typ string
-}{
-	{"mheap_", "runtime.mheap"},
-	{"memstats", "runtime.mstats"},
-	{"sched", "runtime.schedt"},
-	{"allfin", "*runtime.finblock"},
-	{"finq", "*runtime.finblock"},
-	{"allgs", "[]*runtime.g"},
-	{"allm", "*runtime.m"},
-	{"allp", "[1]*p"}, // TODO: type depends on _MaxGomaxprocs
-	{"modulesSlice", "*[]*runtime.moduledata"},
-	{"buildVersion", "string"},
+	return p, nil
 }
 
 func (p *Program) readSpans() {
-	mheap := p.runtime["mheap_"]
+	mheap := p.rtGlobals["mheap_"]
 
 	spanTableStart := mheap.Field("spans").SlicePtr().Address()
 	spanTableEnd := spanTableStart.Add(mheap.Field("spans").SliceCap() * p.proc.PtrSize())
@@ -260,14 +230,7 @@ func (p *Program) readSpans() {
 }
 
 func (p *Program) readModules() {
-	// Make a runtime name -> Type map for existing DWARF types.
-	p.runtimeNameMap = map[string][]*Type{}
-	for dt, t := range p.dwarfMap {
-		name := runtimeName(dt)
-		p.runtimeNameMap[name] = append(p.runtimeNameMap[name], t)
-	}
-
-	ms := p.runtime["modulesSlice"].Deref()
+	ms := p.rtGlobals["modulesSlice"].Cast("*[]*runtime.moduledata").Deref()
 	n := ms.SliceLen()
 	for i := int64(0); i < n; i++ {
 		md := ms.SliceIndex(i).Deref()
@@ -343,13 +306,13 @@ func (t *Type) ptrs1(s []int64, off int64) []int64 {
 // Convert the address of a runtime._type to a *Type.
 // Guaranteed to return a non-nil *Type.
 func (p *Program) runtimeType2Type(a core.Address) *Type {
-	if t, ok := p.runtimeMap[a]; ok {
+	if t := p.runtimeMap[a]; t != nil {
 		return t
 	}
 	ptrSize := p.proc.PtrSize()
 
 	// Read runtime._type.size
-	r := region{p: p, a: a, typ: "runtime._type"}
+	r := region{p: p, a: a, typ: p.findType("runtime._type")}
 	size := int64(r.Field("size").Uintptr())
 
 	// Find module this type is in.
@@ -413,13 +376,12 @@ func (p *Program) runtimeType2Type(a core.Address) *Type {
 	} else {
 		// There's no corresponding DWARF type.  Make our own.
 		t = &Type{name: name, Size: size, Kind: KindStruct}
-		p.types = append(p.types, t)
 		n := t.Size / ptrSize
 
 		// Types to use for ptr/nonptr fields of runtime types which
 		// have no corresponding DWARF type.
-		ptr := p.runtimeNameMap["unsafe.Pointer"][0]
-		nonptr := p.runtimeNameMap["uintptr"][0]
+		ptr := p.findType("unsafe.Pointer")
+		nonptr := p.findType("uintptr")
 		if ptr == nil || nonptr == nil {
 			panic("ptr / nonptr standins missing")
 		}
@@ -457,7 +419,7 @@ func (m *module) readFunc(r region, pcln region) *Func {
 	f.frameSize.read(r.p.proc, pcln.SliceIndex(int64(r.Field("pcsp").Int32())).a)
 
 	// Parse pcdata and funcdata, which are laid out beyond the end of the _func.
-	a := r.a.Add(int64(r.p.rtStructs["runtime._func"].size))
+	a := r.a.Add(int64(r.p.findType("runtime._func").Size))
 	n := r.Field("npcdata").Int32()
 	for i := int32(0); i < n; i++ {
 		f.pcdata = append(f.pcdata, r.p.proc.ReadInt32(a))
@@ -485,7 +447,7 @@ func pcdata(r region, pcln region, n int64) core.Address {
 	if n >= int64(r.Field("npcdata").Int32()) {
 		return 0
 	}
-	a := r.a.Add(int64(r.p.rtStructs["runtime._func"].size + 4*n))
+	a := r.a.Add(int64(r.p.findType("runtime._func").Size + 4*n))
 
 	off := r.p.proc.ReadInt32(a)
 	return pcln.SliceIndex(int64(off)).a
@@ -501,12 +463,12 @@ func funcdata(r region, n int64) core.Address {
 	if x&1 != 0 && r.p.proc.PtrSize() == 8 {
 		x++
 	}
-	a := r.a.Add(int64(r.p.rtStructs["runtime._func"].size + 4*int64(x) + r.p.proc.PtrSize()*n))
+	a := r.a.Add(int64(r.p.findType("runtime._func").Size + 4*int64(x) + r.p.proc.PtrSize()*n))
 	return r.p.proc.ReadPtr(a)
 }
 
 func (p *Program) readMs() {
-	mp := p.runtime["allm"]
+	mp := p.rtGlobals["allm"]
 	for mp.Address() != 0 {
 		m := mp.Deref()
 		gs := m.Field("gsignal")
@@ -521,7 +483,7 @@ func (p *Program) readMs() {
 
 func (p *Program) readGs() {
 	// TODO: figure out how to "flush" running Gs.
-	allgs := p.runtime["allgs"]
+	allgs := p.rtGlobals["allgs"]
 	n := allgs.SliceLen()
 	for i := int64(0); i < n; i++ {
 		r := allgs.SliceIndex(i).Deref()
@@ -625,7 +587,7 @@ func (p *Program) readFrame(sp, pc core.Address) *Frame {
 	// Find live ptrs in locals
 	live := map[core.Address]bool{}
 	if x := int(p.rtConstants["_FUNCDATA_LocalsPointerMaps"]); x < len(f.funcdata) {
-		locals := region{p: p, a: f.funcdata[x], typ: "runtime.stackmap"}
+		locals := region{p: p, a: f.funcdata[x], typ: p.findType("runtime.stackmap")}
 		n := locals.Field("n").Int32()       // # of bitmaps
 		nbit := locals.Field("nbit").Int32() // # of bits per bitmap
 		idx := f.stackMap.find(off)
@@ -645,7 +607,7 @@ func (p *Program) readFrame(sp, pc core.Address) *Frame {
 	}
 	// Same for args
 	if x := int(p.rtConstants["_FUNCDATA_ArgsPointerMaps"]); x < len(f.funcdata) {
-		args := region{p: p, a: f.funcdata[x], typ: "runtime.stackmap"}
+		args := region{p: p, a: f.funcdata[x], typ: p.findType("runtime.stackmap")}
 		n := args.Field("n").Int32()       // # of bitmaps
 		nbit := args.Field("nbit").Int32() // # of bits per bitmap
 		idx := f.stackMap.find(off)