internal/gocore/dwarf.go - debug - Git at Google

 // Copyright 2017 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 gocore

 import (
 	"debug/dwarf"
 	"errors"
 	"fmt"
 	"reflect"
 	"strings"

 	"golang.org/x/debug/dwtest"
 	"golang.org/x/debug/internal/core"

 	"golang.org/x/debug/third_party/delve/dwarf/godwarf"
 	"golang.org/x/debug/third_party/delve/dwarf/loclist"
 	"golang.org/x/debug/third_party/delve/dwarf/op"
 	"golang.org/x/debug/third_party/delve/dwarf/regnum"
 )

 const (
 	AttrGoKind        dwarf.Attr = 0x2900
 	AttrGoRuntimeType dwarf.Attr = 0x2904
 )

 func readDWARFTypes(p *core.Process) (map[dwarf.Type]*Type, map[core.Address]*Type, error) {
 	d, err := p.DWARF()
 	if err != nil {
 		return nil, nil, fmt.Errorf("failed to read DWARF: %v", err)
 	}
 	dwarfMap := make(map[dwarf.Type]*Type)
 	addrMap := make(map[core.Address]*Type)
 	syms, _ := p.Symbols() // It's OK to ignore the error. If we don't have symbols, that's OK; it's a soft error.
 	// It's OK if typBase is 0 and not present. We won't be able to type the heap, probably,
 	// but it may still be useful (though painful) to someone to try and debug the core, so don't
 	// error out here.
 	typBase := syms["runtime.types"]

 	// 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() {
 		if isNonGoCU(e) {
 			r.SkipChildren()
 			continue
 		}
 		switch e.Tag {
 		case dwarf.TagArrayType, dwarf.TagPointerType, dwarf.TagStructType, dwarf.TagBaseType, dwarf.TagSubroutineType, dwarf.TagTypedef:
 			dt, err := d.Type(e.Offset)
 			if err != nil {
 				continue
 			}
 			t := &Type{Name: gocoreName(dt), Size: dwarfSize(dt, p.PtrSize())}
 			if goKind, ok := e.Val(AttrGoKind).(int64); ok {
 				t.goKind = reflect.Kind(goKind)
 			}
 			// Guard against typBase being zero. In reality, it's very unlikely for the DWARF
 			// to be present but typBase to be zero, but let's just be defensive. addrMap is
 			// only really necessary for typing the heap, which is "optional."
 			if typBase != 0 {
 				if offset, ok := e.Val(AttrGoRuntimeType).(uint64); ok {
 					// N.B. AttrGoRuntimeType is not defined for typedefs, so addrMap will
 					// always refer to the base type.
 					t.goAddr = typBase.Add(int64(offset))
 					addrMap[typBase.Add(int64(offset))] = t
 				}
 			}
 			dwarfMap[dt] = t
 			types = append(types, t)
 		}
 	}

 	// Fill in fields of types. Postponed until now so we're sure
 	// we have all the Types allocated and available.
 	for dt, t := range dwarfMap {
 		switch x := dt.(type) {
 		case *dwarf.ArrayType:
 			t.Kind = KindArray
 			t.Elem = dwarfMap[x.Type]
 			t.Count = x.Count
 		case *dwarf.PtrType:
 			t.Kind = KindPtr
 			// unsafe.Pointer has a void base type.
 			if _, ok := x.Type.(*dwarf.VoidType); !ok {
 				t.Elem = dwarfMap[x.Type]
 			}
 		case *dwarf.StructType:
 			t.Kind = KindStruct
 			for _, f := range x.Field {
 				fType := dwarfMap[f.Type]
 				if fType == nil {
 					// Weird case: arrays of size 0 in structs, like
 					// Sysinfo_t.X_f. Synthesize a type so things later don't
 					// get sad.
 					if arr, ok := f.Type.(*dwarf.ArrayType); ok && arr.Count == 0 {
 						fType = &Type{
 							Name:  f.Type.String(),
 							Kind:  KindArray,
 							Count: arr.Count,
 							Elem:  dwarfMap[arr.Type],
 						}
 					} else {
 						return nil, nil, fmt.Errorf(
 							"found a nil ftype for field %s.%s, type %s (%s) on ",
 							x.StructName, f.Name, f.Type, reflect.TypeOf(f.Type))
 					}
 				}
 				t.Fields = append(t.Fields, Field{Name: f.Name, Type: fType, Off: f.ByteOffset})
 			}
 		case *dwarf.BoolType:
 			t.Kind = KindBool
 		case *dwarf.IntType:
 			t.Kind = KindInt
 		case *dwarf.UintType:
 			t.Kind = KindUint
 		case *dwarf.FloatType:
 			t.Kind = KindFloat
 		case *dwarf.ComplexType:
 			t.Kind = KindComplex
 		case *dwarf.FuncType:
 			t.Kind = KindFunc
 		case *dwarf.TypedefType:
 			// handle these types in the loop below
 		default:
 			return nil, nil, fmt.Errorf("unknown type %s %T", dt, dt)
 		}
 	}

 	// Detect strings & slices
 	for _, t := range types {
 		if t.Kind != KindStruct {
 			continue
 		}
 		switch t.goKind {
 		case reflect.String:
 			t.Kind = KindString
 			t.Elem = t.Fields[0].Type.Elem // TODO: check that it is always uint8.
 			t.Fields = nil
 		case reflect.Slice:
 			t.Kind = KindSlice
 			t.Elem = t.Fields[0].Type.Elem
 			t.Fields = nil
 		}
 	}

 	// Copy info from base types into typedefs.
 	for dt, t := range dwarfMap {
 		tt, ok := dt.(*dwarf.TypedefType)
 		if !ok {
 			continue
 		}
 		base := tt.Type
 		// Walk typedef chain until we reach a non-typedef type.
 		for {
 			if x, ok := base.(*dwarf.TypedefType); ok {
 				base = x.Type
 				continue
 			}
 			break
 		}
 		bt := dwarfMap[base]

 		// Copy type info from base. Everything except the name.
 		name := t.Name
 		*t = *bt
 		t.Name = name

 		// Detect some special types. If the base is some particular type,
 		// then the alias gets marked as special.
 		// We have aliases like:
 		//   interface {}              -> struct runtime.eface
 		//   error                     -> struct runtime.iface
 		// Note: the base itself does not get marked as special.
 		// (Unlike strings and slices, where they do.)
 		if bt.Name == "runtime.eface" {
 			t.Kind = KindEface
 			t.Fields = nil
 		}
 		if bt.Name == "runtime.iface" {
 			t.Kind = KindIface
 			t.Fields = nil
 		}
 	}
 	return dwarfMap, addrMap, nil
 }

 func isNonGoCU(e *dwarf.Entry) bool {
 	if e.Tag != dwarf.TagCompileUnit {
 		return false
 	}
 	prod, ok := e.Val(dwarf.AttrProducer).(string)
 	if !ok {
 		return true
 	}
 	return !strings.Contains(prod, "Go cmd/compile")
 }

 // dwarfSize is used to compute the size of a DWARF type.
 // dt.Size() is wrong when it returns a negative number.
 // This function implements just enough to correct the bad behavior.
 func dwarfSize(dt dwarf.Type, ptrSize int64) int64 {
 	s := dt.Size()
 	if s >= 0 {
 		return s
 	}
 	switch x := dt.(type) {
 	case *dwarf.FuncType:
 		return ptrSize // Fix for issue 21097.
 	case *dwarf.ArrayType:
 		return x.Count * dwarfSize(x.Type, ptrSize)
 	case *dwarf.TypedefType:
 		return dwarfSize(x.Type, ptrSize)
 	default:
 		panic(fmt.Sprintf("unhandled: %s, %T", x, x))
 	}
 }

 // gocoreName generates the name this package uses to refer to a dwarf type.
 // This name differs from the dwarf name in that it stays closer to the Go name for the type.
 // For instance (dwarf name -> gocoreName)
 //
 //	struct runtime.siginfo -> runtime.siginfo
 //	*void -> unsafe.Pointer
 //	struct struct { runtime.signalLock uint32; runtime.hz int32 } -> struct { signalLock uint32; hz int32 }
 func gocoreName(dt dwarf.Type) string {
 	switch x := dt.(type) {
 	case *dwarf.PtrType:
 		if _, ok := x.Type.(*dwarf.VoidType); ok {
 			return "unsafe.Pointer"
 		}
 		return "*" + gocoreName(x.Type)
 	case *dwarf.ArrayType:
 		return fmt.Sprintf("[%d]%s", x.Count, gocoreName(x.Type))
 	case *dwarf.StructType:
 		if !strings.HasPrefix(x.StructName, "struct {") {
 			// This is a named type, return that name.
 			return x.StructName
 		}
 		// Build gocore name from the DWARF fields.
 		s := "struct {"
 		first := true
 		for _, f := range x.Field {
 			if !first {
 				s += ";"
 			}
 			name := f.Name
 			if i := strings.Index(name, "."); i >= 0 {
 				// Remove pkg path from field names.
 				name = name[i+1:]
 			}
 			s += fmt.Sprintf(" %s %s", name, gocoreName(f.Type))
 			first = false
 		}
 		s += " }"
 		return s
 	default:
 		return dt.String()
 	}
 }

 type constsMap map[string]int64

 func (c constsMap) get(s string) int64 {
 	v, ok := c[s]
 	if !ok {
 		panic("failed to find constant " + s)
 	}
 	return v
 }

 func (c constsMap) find(s string) (int64, bool) {
 	v, ok := c[s]
 	return v, ok
 }

 func readDWARFConstants(p *core.Process) (constsMap, error) {
 	d, err := p.DWARF()
 	if err != nil {
 		return nil, fmt.Errorf("failed to read DWARF: %v", err)
 	}
 	consts := map[string]int64{}

 	r := d.Reader()
 	for e, err := r.Next(); e != nil && err == nil; e, err = r.Next() {
 		if e.Tag != dwarf.TagConstant {
 			continue
 		}
 		f := e.AttrField(dwarf.AttrName)
 		if f == nil {
 			continue
 		}
 		name := f.Val.(string)
 		c := e.AttrField(dwarf.AttrConstValue)
 		if c == nil {
 			continue
 		}
 		consts[name] = c.Val.(int64)
 	}
 	return consts, nil
 }

 func readDWARFGlobals(p *core.Process, nRoots *int, dwarfTypeMap map[dwarf.Type]*Type) ([]*Root, error) {
 	d, err := p.DWARF()
 	if err != nil {
 		return nil, fmt.Errorf("failed to read DWARF: %v", err)
 	}
 	var roots []*Root
 	r := d.Reader()
 	for e, err := r.Next(); e != nil && err == nil; e, err = r.Next() {
 		if isNonGoCU(e) {
 			r.SkipChildren()
 			continue
 		}

 		if e.Tag != dwarf.TagVariable {
 			continue
 		}
 		f := e.AttrField(dwarf.AttrLocation)
 		if f == nil {
 			continue
 		}
 		if f.Class != dwarf.ClassExprLoc {
 			// Globals are all encoded with this class.
 			continue
 		}
 		loc := f.Val.([]byte)
 		if len(loc) == 0 || loc[0] != byte(op.DW_OP_addr) {
 			continue
 		}
 		var a core.Address
 		if p.PtrSize() == 8 {
 			a = core.Address(p.ByteOrder().Uint64(loc[1:]))
 		} else {
 			a = core.Address(p.ByteOrder().Uint32(loc[1:]))
 		}
 		a = a.Add(int64(p.StaticBase()))
 		if !p.Writeable(a) {
 			// Read-only globals can't have heap pointers.
 			// TODO: keep roots around anyway?
 			continue
 		}
 		f = e.AttrField(dwarf.AttrType)
 		if f == nil {
 			continue
 		}
 		dt, err := d.Type(f.Val.(dwarf.Offset))
 		if err != nil {
 			return nil, err
 		}
 		if _, ok := dt.(*dwarf.UnspecifiedType); ok {
 			continue // Ignore markers like data/edata.
 		}
 		nf := e.AttrField(dwarf.AttrName)
 		if nf == nil {
 			continue
 		}
 		typ := dwarfTypeMap[dt]
 		roots = append(roots, makeMemRoot(nRoots, nf.Val.(string), typ, nil, a))
 	}
 	return roots, nil
 }

 type dwarfVarKind int

 const (
 	dwarfVarUnknown dwarfVarKind = iota
 	dwarfParam
 	dwarfLocal
 )

 type dwarfVar struct {
 	lowPC, highPC core.Address
 	kind          dwarfVarKind
 	name          string
 	instr         []byte
 	typ           *Type
 }

 func readDWARFVars(p *core.Process, fns *funcTab, dwarfTypeMap map[dwarf.Type]*Type) (map[*Func][]dwarfVar, error) {
 	d, err := p.DWARF()
 	if err != nil {
 		return nil, fmt.Errorf("failed to read DWARF: %v", err)
 	}
 	dLocSec, err := p.DWARFLoc()
 	if err != nil {
 		return nil, fmt.Errorf("failed to read DWARF: %v", err)
 	}
 	dLocListsSec, derr := p.DWARFLocLists()
 	if derr != nil {
 		return nil, fmt.Errorf("failed to read DWARF: %v", derr)
 	}
 	dAddrSec, daerr := p.DWARFAddr()
 	if daerr != nil {
 		return nil, fmt.Errorf("failed to read DWARF: %v", daerr)
 	}
 	debugAddrSec := godwarf.ParseAddr(dAddrSec)
 	vars := make(map[*Func][]dwarfVar)
 	var curfn *Func
 	r := d.Reader()
 	addrBase := uint64(0)
 	unitVersion := 4
 	for e, err := r.Next(); e != nil && err == nil; e, err = r.Next() {
 		if isNonGoCU(e) {
 			r.SkipChildren()
 			continue
 		}
 		if e.Tag == dwarf.TagCompileUnit {
 			// Determine whether we're looking at DWARF version 5 or
 			// some version prior to 5.  At the moment the DWARF
 			// reading machinery in debug/dwarf keeps track of DWARF
 			// version for each unit but doesn't expose this info to
 			// clients, so we need to do the detection indirectly,
 			// here by looking for an attribute that only gets generated
 			// if DWARF 5 is being used.
 			if f := e.AttrField(dwarf.AttrAddrBase); f != nil {
 				addrBase = uint64(f.Val.(int64))
 				unitVersion = 5
 			} else {
 				unitVersion = 4
 			}
 		}
 		if e.Tag == dwarf.TagSubprogram {
 			if e.AttrField(dwarf.AttrLowpc) == nil ||
 				e.AttrField(dwarf.AttrHighpc) == nil {
 				continue
 			}

 			// Collect the start/end PC for the func. The format/class of
 			// the high PC attr may vary depending on which DWARF version
 			// we're generating; invoke a helper to handle the various
 			// possibilities.
 			lowpc, highpc, perr := dwtest.SubprogLoAndHighPc(e)
 			if perr != nil {
 				return nil, fmt.Errorf("subprog die malformed: %v", perr)
 			}
 			fmin := core.Address(lowpc + p.StaticBase())
 			fmax := core.Address(highpc + p.StaticBase())
 			f := fns.find(fmin)
 			if f == nil {
 				// some func Go doesn't know about. C?
 				curfn = nil
 			} else {
 				if f.entry != fmin {
 					return nil, errors.New("dwarf and runtime don't agree about start of " + f.name)
 				}
 				if fns.find(fmax-1) != f {
 					return nil, errors.New("function ranges don't match for " + f.name)
 				}
 				curfn = f
 			}
 			continue
 		}
 		if e.Tag != dwarf.TagVariable && e.Tag != dwarf.TagFormalParameter {
 			continue
 		}
 		var kind dwarfVarKind
 		switch e.Tag {
 		case dwarf.TagFormalParameter:
 			kind = dwarfParam
 		case dwarf.TagVariable:
 			kind = dwarfLocal
 		}
 		aloc := e.AttrField(dwarf.AttrLocation)
 		if aloc == nil {
 			continue
 		}
 		if aloc.Class != dwarf.ClassLocListPtr {
 			continue
 		}

 		// Read attributes for some high-level information.
 		f := e.AttrField(dwarf.AttrType)
 		if f == nil {
 			continue
 		}
 		dt, err := d.Type(f.Val.(dwarf.Offset))
 		if err != nil {
 			return nil, err
 		}
 		nf := e.AttrField(dwarf.AttrName)
 		if nf == nil {
 			continue
 		}
 		name := nf.Val.(string)

 		// FIXME A note on the code above: we're screening out
 		// variables that don't have a specific name and type, which
 		// on the surface seems workable, however this also rejects
 		// vars corresponding to "concrete" instances of vars that
 		// have been inlined, which is almost certainly a mistake. For
 		// more on concrete/abstract variables see
 		// https://github.com/golang/proposal/blob/master/design/22080-dwarf-inlining.md#how-the-generated-dwarf-should-look,
 		// which has examples.  Instead what the code above should be
 		// doing is caching any abstract variables it encounters in a
 		// map (indexed by DWARF offset), then when it encounters a
 		// concrete var, pick the name and type up from the abstract
 		// variable.

 		switch unitVersion {
 		case 5:
 			{
 				// No .debug_loclists section, can't make progress.
 				if len(dLocListsSec) == 0 {
 					continue
 				}

 				debugAddr := debugAddrSec.GetSubsection(addrBase)
 				// Read the location lists.
 				locListOff := aloc.Val.(int64)
 				dr := loclist.NewDwarf5Reader(dLocListsSec)
 				elist, err := dr.Enumerate(locListOff, p.StaticBase(), debugAddr)
 				if err != nil {
 					return nil, err
 				}
 				for _, e := range elist {
 					vars[curfn] = append(vars[curfn], dwarfVar{
 						lowPC:  core.Address(e.LowPC),
 						highPC: core.Address(e.HighPC),
 						kind:   kind,
 						instr:  e.Instr,
 						name:   name,
 						typ:    dwarfTypeMap[dt],
 					})
 				}
 			}
 		default:
 			{
 				// No .debug_loc section, can't make progress.
 				if len(dLocSec) == 0 {
 					continue
 				}

 				// Read the location list.
 				locListOff := aloc.Val.(int64)
 				dr := loclist.NewDwarf2Reader(dLocSec, int(p.PtrSize()))
 				dr.Seek(int(locListOff))
 				var base uint64
 				var e loclist.Entry
 				for dr.Next(&e) {
 					if e.BaseAddressSelection() {
 						base = e.HighPC + p.StaticBase()
 						continue
 					}
 					vars[curfn] = append(vars[curfn], dwarfVar{
 						lowPC:  core.Address(e.LowPC + base),
 						highPC: core.Address(e.HighPC + base),
 						kind:   kind,
 						instr:  e.Instr,
 						name:   name,
 						typ:    dwarfTypeMap[dt],
 					})
 				}
 			}
 		}
 	}
 	return vars, nil
 }

 func hardwareRegs2DWARF(hregs []core.Register) []*op.DwarfRegister {
 	n := regnum.AMD64MaxRegNum()
 	dregs := make([]*op.DwarfRegister, n)
 	for _, hreg := range hregs {
 		dwn, ok := regnum.AMD64NameToDwarf[hreg.Name]
 		if !ok {
 			continue
 		}
 		dreg := op.DwarfRegisterFromUint64(hreg.Value)
 		dreg.FillBytes()
 		dregs[dwn] = dreg
 	}
 	return dregs
 }

 /* Dwarf encoding notes

 type XXX sss

 translates to a dwarf type pkg.XXX of the type of sss (uint, float, ...)

 exception: if sss is a struct or array, then we get two types, the "unnamed" and "named" type.
 The unnamed type is a dwarf struct type with name "struct pkg.XXX" or a dwarf array type with
 name [N]elem.
 Then there is a typedef with pkg.XXX pointing to "struct pkg.XXX" or [N]elem.

 For structures, lowercase field names are prepended with the package name (pkg path?).

 type XXX interface{}
 pkg.XXX is a typedef to "struct runtime.eface"
 type XXX interface{f()}
 pkg.XXX is a typedef to "struct runtime.iface"

 Sometimes there is even a chain of identically-named typedefs. I have no idea why.
 main.XXX -> main.XXX -> struct runtime.iface

 */
	// Copyright 2017 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 gocore

	import (
	"debug/dwarf"
	"errors"
	"fmt"
	"reflect"
	"strings"

	"golang.org/x/debug/dwtest"
	"golang.org/x/debug/internal/core"

	"golang.org/x/debug/third_party/delve/dwarf/godwarf"
	"golang.org/x/debug/third_party/delve/dwarf/loclist"
	"golang.org/x/debug/third_party/delve/dwarf/op"
	"golang.org/x/debug/third_party/delve/dwarf/regnum"
	)

	const (
	AttrGoKind dwarf.Attr = 0x2900
	AttrGoRuntimeType dwarf.Attr = 0x2904
	)

	func readDWARFTypes(p core.Process) (map[dwarf.Type]Type, map[core.Address]*Type, error) {
	d, err := p.DWARF()
	if err != nil {
	return nil, nil, fmt.Errorf("failed to read DWARF: %v", err)
	}
	dwarfMap := make(map[dwarf.Type]*Type)
	addrMap := make(map[core.Address]*Type)
	syms, _ := p.Symbols() // It's OK to ignore the error. If we don't have symbols, that's OK; it's a soft error.
	// It's OK if typBase is 0 and not present. We won't be able to type the heap, probably,
	// but it may still be useful (though painful) to someone to try and debug the core, so don't
	// error out here.
	typBase := syms["runtime.types"]

	// 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() {
	if isNonGoCU(e) {
	r.SkipChildren()
	continue
	}
	switch e.Tag {
	case dwarf.TagArrayType, dwarf.TagPointerType, dwarf.TagStructType, dwarf.TagBaseType, dwarf.TagSubroutineType, dwarf.TagTypedef:
	dt, err := d.Type(e.Offset)
	if err != nil {
	continue
	}
	t := &Type{Name: gocoreName(dt), Size: dwarfSize(dt, p.PtrSize())}
	if goKind, ok := e.Val(AttrGoKind).(int64); ok {
	t.goKind = reflect.Kind(goKind)
	}
	// Guard against typBase being zero. In reality, it's very unlikely for the DWARF
	// to be present but typBase to be zero, but let's just be defensive. addrMap is
	// only really necessary for typing the heap, which is "optional."
	if typBase != 0 {
	if offset, ok := e.Val(AttrGoRuntimeType).(uint64); ok {
	// N.B. AttrGoRuntimeType is not defined for typedefs, so addrMap will
	// always refer to the base type.
	t.goAddr = typBase.Add(int64(offset))
	addrMap[typBase.Add(int64(offset))] = t
	}
	}
	dwarfMap[dt] = t
	types = append(types, t)
	}
	}

	// Fill in fields of types. Postponed until now so we're sure
	// we have all the Types allocated and available.
	for dt, t := range dwarfMap {
	switch x := dt.(type) {
	case *dwarf.ArrayType:
	t.Kind = KindArray
	t.Elem = dwarfMap[x.Type]
	t.Count = x.Count
	case *dwarf.PtrType:
	t.Kind = KindPtr
	// unsafe.Pointer has a void base type.
	if _, ok := x.Type.(*dwarf.VoidType); !ok {
	t.Elem = dwarfMap[x.Type]
	}
	case *dwarf.StructType:
	t.Kind = KindStruct
	for _, f := range x.Field {
	fType := dwarfMap[f.Type]
	if fType == nil {
	// Weird case: arrays of size 0 in structs, like
	// Sysinfo_t.X_f. Synthesize a type so things later don't
	// get sad.
	if arr, ok := f.Type.(*dwarf.ArrayType); ok && arr.Count == 0 {
	fType = &Type{
	Name: f.Type.String(),
	Kind: KindArray,
	Count: arr.Count,
	Elem: dwarfMap[arr.Type],
	}
	} else {
	return nil, nil, fmt.Errorf(
	"found a nil ftype for field %s.%s, type %s (%s) on ",
	x.StructName, f.Name, f.Type, reflect.TypeOf(f.Type))
	}
	}
	t.Fields = append(t.Fields, Field{Name: f.Name, Type: fType, Off: f.ByteOffset})
	}
	case *dwarf.BoolType:
	t.Kind = KindBool
	case *dwarf.IntType:
	t.Kind = KindInt
	case *dwarf.UintType:
	t.Kind = KindUint
	case *dwarf.FloatType:
	t.Kind = KindFloat
	case *dwarf.ComplexType:
	t.Kind = KindComplex
	case *dwarf.FuncType:
	t.Kind = KindFunc
	case *dwarf.TypedefType:
	// handle these types in the loop below
	default:
	return nil, nil, fmt.Errorf("unknown type %s %T", dt, dt)
	}
	}

	// Detect strings & slices
	for _, t := range types {
	if t.Kind != KindStruct {
	continue
	}
	switch t.goKind {
	case reflect.String:
	t.Kind = KindString
	t.Elem = t.Fields[0].Type.Elem // TODO: check that it is always uint8.
	t.Fields = nil
	case reflect.Slice:
	t.Kind = KindSlice
	t.Elem = t.Fields[0].Type.Elem
	t.Fields = nil
	}
	}

	// Copy info from base types into typedefs.
	for dt, t := range dwarfMap {
	tt, ok := dt.(*dwarf.TypedefType)
	if !ok {
	continue
	}
	base := tt.Type
	// Walk typedef chain until we reach a non-typedef type.
	for {
	if x, ok := base.(*dwarf.TypedefType); ok {
	base = x.Type
	continue
	}
	break
	}
	bt := dwarfMap[base]

	// Copy type info from base. Everything except the name.
	name := t.Name
	t = bt
	t.Name = name

	// Detect some special types. If the base is some particular type,
	// then the alias gets marked as special.
	// We have aliases like:
	// interface {} -> struct runtime.eface
	// error -> struct runtime.iface
	// Note: the base itself does not get marked as special.
	// (Unlike strings and slices, where they do.)
	if bt.Name == "runtime.eface" {
	t.Kind = KindEface
	t.Fields = nil
	}
	if bt.Name == "runtime.iface" {
	t.Kind = KindIface
	t.Fields = nil
	}
	}
	return dwarfMap, addrMap, nil
	}

	func isNonGoCU(e *dwarf.Entry) bool {
	if e.Tag != dwarf.TagCompileUnit {
	return false
	}
	prod, ok := e.Val(dwarf.AttrProducer).(string)
	if !ok {
	return true
	}
	return !strings.Contains(prod, "Go cmd/compile")
	}

	// dwarfSize is used to compute the size of a DWARF type.
	// dt.Size() is wrong when it returns a negative number.
	// This function implements just enough to correct the bad behavior.
	func dwarfSize(dt dwarf.Type, ptrSize int64) int64 {
	s := dt.Size()
	if s >= 0 {
	return s
	}
	switch x := dt.(type) {
	case *dwarf.FuncType:
	return ptrSize // Fix for issue 21097.
	case *dwarf.ArrayType:
	return x.Count * dwarfSize(x.Type, ptrSize)
	case *dwarf.TypedefType:
	return dwarfSize(x.Type, ptrSize)
	default:
	panic(fmt.Sprintf("unhandled: %s, %T", x, x))
	}
	}

	// gocoreName generates the name this package uses to refer to a dwarf type.
	// This name differs from the dwarf name in that it stays closer to the Go name for the type.
	// For instance (dwarf name -> gocoreName)
	//
	// struct runtime.siginfo -> runtime.siginfo
	// *void -> unsafe.Pointer
	// struct struct { runtime.signalLock uint32; runtime.hz int32 } -> struct { signalLock uint32; hz int32 }
	func gocoreName(dt dwarf.Type) string {
	switch x := dt.(type) {
	case *dwarf.PtrType:
	if _, ok := x.Type.(*dwarf.VoidType); ok {
	return "unsafe.Pointer"
	}
	return "*" + gocoreName(x.Type)
	case *dwarf.ArrayType:
	return fmt.Sprintf("[%d]%s", x.Count, gocoreName(x.Type))
	case *dwarf.StructType:
	if !strings.HasPrefix(x.StructName, "struct {") {
	// This is a named type, return that name.
	return x.StructName
	}
	// Build gocore name from the DWARF fields.
	s := "struct {"
	first := true
	for _, f := range x.Field {
	if !first {
	s += ";"
	}
	name := f.Name
	if i := strings.Index(name, "."); i >= 0 {
	// Remove pkg path from field names.
	name = name[i+1:]
	}
	s += fmt.Sprintf(" %s %s", name, gocoreName(f.Type))
	first = false
	}
	s += " }"
	return s
	default:
	return dt.String()
	}
	}

	type constsMap map[string]int64

	func (c constsMap) get(s string) int64 {
	v, ok := c[s]
	if !ok {
	panic("failed to find constant " + s)
	}
	return v
	}

	func (c constsMap) find(s string) (int64, bool) {
	v, ok := c[s]
	return v, ok
	}

	func readDWARFConstants(p *core.Process) (constsMap, error) {
	d, err := p.DWARF()
	if err != nil {
	return nil, fmt.Errorf("failed to read DWARF: %v", err)
	}
	consts := map[string]int64{}

	r := d.Reader()
	for e, err := r.Next(); e != nil && err == nil; e, err = r.Next() {
	if e.Tag != dwarf.TagConstant {
	continue
	}
	f := e.AttrField(dwarf.AttrName)
	if f == nil {
	continue
	}
	name := f.Val.(string)
	c := e.AttrField(dwarf.AttrConstValue)
	if c == nil {
	continue
	}
	consts[name] = c.Val.(int64)
	}
	return consts, nil
	}

	func readDWARFGlobals(p core.Process, nRoots int, dwarfTypeMap map[dwarf.Type]Type) ([]Root, error) {
	d, err := p.DWARF()
	if err != nil {
	return nil, fmt.Errorf("failed to read DWARF: %v", err)
	}
	var roots []*Root
	r := d.Reader()
	for e, err := r.Next(); e != nil && err == nil; e, err = r.Next() {
	if isNonGoCU(e) {
	r.SkipChildren()
	continue
	}

	if e.Tag != dwarf.TagVariable {
	continue
	}
	f := e.AttrField(dwarf.AttrLocation)
	if f == nil {
	continue
	}
	if f.Class != dwarf.ClassExprLoc {
	// Globals are all encoded with this class.
	continue
	}
	loc := f.Val.([]byte)
	if len(loc) == 0 \|\| loc[0] != byte(op.DW_OP_addr) {
	continue
	}
	var a core.Address
	if p.PtrSize() == 8 {
	a = core.Address(p.ByteOrder().Uint64(loc[1:]))
	} else {
	a = core.Address(p.ByteOrder().Uint32(loc[1:]))
	}
	a = a.Add(int64(p.StaticBase()))
	if !p.Writeable(a) {
	// Read-only globals can't have heap pointers.
	// TODO: keep roots around anyway?
	continue
	}
	f = e.AttrField(dwarf.AttrType)
	if f == nil {
	continue
	}
	dt, err := d.Type(f.Val.(dwarf.Offset))
	if err != nil {
	return nil, err
	}
	if _, ok := dt.(*dwarf.UnspecifiedType); ok {
	continue // Ignore markers like data/edata.
	}
	nf := e.AttrField(dwarf.AttrName)
	if nf == nil {
	continue
	}
	typ := dwarfTypeMap[dt]
	roots = append(roots, makeMemRoot(nRoots, nf.Val.(string), typ, nil, a))
	}
	return roots, nil
	}

	type dwarfVarKind int

	const (
	dwarfVarUnknown dwarfVarKind = iota
	dwarfParam
	dwarfLocal
	)

	type dwarfVar struct {
	lowPC, highPC core.Address
	kind dwarfVarKind
	name string
	instr []byte
	typ *Type
	}

	func readDWARFVars(p core.Process, fns funcTab, dwarfTypeMap map[dwarf.Type]Type) (map[Func][]dwarfVar, error) {
	d, err := p.DWARF()
	if err != nil {
	return nil, fmt.Errorf("failed to read DWARF: %v", err)
	}
	dLocSec, err := p.DWARFLoc()
	if err != nil {
	return nil, fmt.Errorf("failed to read DWARF: %v", err)
	}
	dLocListsSec, derr := p.DWARFLocLists()
	if derr != nil {
	return nil, fmt.Errorf("failed to read DWARF: %v", derr)
	}
	dAddrSec, daerr := p.DWARFAddr()
	if daerr != nil {
	return nil, fmt.Errorf("failed to read DWARF: %v", daerr)
	}
	debugAddrSec := godwarf.ParseAddr(dAddrSec)
	vars := make(map[*Func][]dwarfVar)
	var curfn *Func
	r := d.Reader()
	addrBase := uint64(0)
	unitVersion := 4
	for e, err := r.Next(); e != nil && err == nil; e, err = r.Next() {
	if isNonGoCU(e) {
	r.SkipChildren()
	continue
	}
	if e.Tag == dwarf.TagCompileUnit {
	// Determine whether we're looking at DWARF version 5 or
	// some version prior to 5. At the moment the DWARF
	// reading machinery in debug/dwarf keeps track of DWARF
	// version for each unit but doesn't expose this info to
	// clients, so we need to do the detection indirectly,
	// here by looking for an attribute that only gets generated
	// if DWARF 5 is being used.
	if f := e.AttrField(dwarf.AttrAddrBase); f != nil {
	addrBase = uint64(f.Val.(int64))
	unitVersion = 5
	} else {
	unitVersion = 4
	}
	}
	if e.Tag == dwarf.TagSubprogram {
	if e.AttrField(dwarf.AttrLowpc) == nil \|\|
	e.AttrField(dwarf.AttrHighpc) == nil {
	continue
	}

	// Collect the start/end PC for the func. The format/class of
	// the high PC attr may vary depending on which DWARF version
	// we're generating; invoke a helper to handle the various
	// possibilities.
	lowpc, highpc, perr := dwtest.SubprogLoAndHighPc(e)
	if perr != nil {
	return nil, fmt.Errorf("subprog die malformed: %v", perr)
	}
	fmin := core.Address(lowpc + p.StaticBase())
	fmax := core.Address(highpc + p.StaticBase())
	f := fns.find(fmin)
	if f == nil {
	// some func Go doesn't know about. C?
	curfn = nil
	} else {
	if f.entry != fmin {
	return nil, errors.New("dwarf and runtime don't agree about start of " + f.name)
	}
	if fns.find(fmax-1) != f {
	return nil, errors.New("function ranges don't match for " + f.name)
	}
	curfn = f
	}
	continue
	}
	if e.Tag != dwarf.TagVariable && e.Tag != dwarf.TagFormalParameter {
	continue
	}
	var kind dwarfVarKind
	switch e.Tag {
	case dwarf.TagFormalParameter:
	kind = dwarfParam
	case dwarf.TagVariable:
	kind = dwarfLocal
	}
	aloc := e.AttrField(dwarf.AttrLocation)
	if aloc == nil {
	continue
	}
	if aloc.Class != dwarf.ClassLocListPtr {
	continue
	}

	// Read attributes for some high-level information.
	f := e.AttrField(dwarf.AttrType)
	if f == nil {
	continue
	}
	dt, err := d.Type(f.Val.(dwarf.Offset))
	if err != nil {
	return nil, err
	}
	nf := e.AttrField(dwarf.AttrName)
	if nf == nil {
	continue
	}
	name := nf.Val.(string)

	// FIXME A note on the code above: we're screening out
	// variables that don't have a specific name and type, which
	// on the surface seems workable, however this also rejects
	// vars corresponding to "concrete" instances of vars that
	// have been inlined, which is almost certainly a mistake. For
	// more on concrete/abstract variables see
	// https://github.com/golang/proposal/blob/master/design/22080-dwarf-inlining.md#how-the-generated-dwarf-should-look,
	// which has examples. Instead what the code above should be
	// doing is caching any abstract variables it encounters in a
	// map (indexed by DWARF offset), then when it encounters a
	// concrete var, pick the name and type up from the abstract
	// variable.

	switch unitVersion {
	case 5:
	{
	// No .debug_loclists section, can't make progress.
	if len(dLocListsSec) == 0 {
	continue
	}

	debugAddr := debugAddrSec.GetSubsection(addrBase)
	// Read the location lists.
	locListOff := aloc.Val.(int64)
	dr := loclist.NewDwarf5Reader(dLocListsSec)
	elist, err := dr.Enumerate(locListOff, p.StaticBase(), debugAddr)
	if err != nil {
	return nil, err
	}
	for _, e := range elist {
	vars[curfn] = append(vars[curfn], dwarfVar{
	lowPC: core.Address(e.LowPC),
	highPC: core.Address(e.HighPC),
	kind: kind,
	instr: e.Instr,
	name: name,
	typ: dwarfTypeMap[dt],
	})
	}
	}
	default:
	{
	// No .debug_loc section, can't make progress.
	if len(dLocSec) == 0 {
	continue
	}

	// Read the location list.
	locListOff := aloc.Val.(int64)
	dr := loclist.NewDwarf2Reader(dLocSec, int(p.PtrSize()))
	dr.Seek(int(locListOff))
	var base uint64
	var e loclist.Entry
	for dr.Next(&e) {
	if e.BaseAddressSelection() {
	base = e.HighPC + p.StaticBase()
	continue
	}
	vars[curfn] = append(vars[curfn], dwarfVar{
	lowPC: core.Address(e.LowPC + base),
	highPC: core.Address(e.HighPC + base),
	kind: kind,
	instr: e.Instr,
	name: name,
	typ: dwarfTypeMap[dt],
	})
	}
	}
	}
	}
	return vars, nil
	}

	func hardwareRegs2DWARF(hregs []core.Register) []*op.DwarfRegister {
	n := regnum.AMD64MaxRegNum()
	dregs := make([]*op.DwarfRegister, n)
	for _, hreg := range hregs {
	dwn, ok := regnum.AMD64NameToDwarf[hreg.Name]
	if !ok {
	continue
	}
	dreg := op.DwarfRegisterFromUint64(hreg.Value)
	dreg.FillBytes()
	dregs[dwn] = dreg
	}
	return dregs
	}

	/* Dwarf encoding notes

	type XXX sss

	translates to a dwarf type pkg.XXX of the type of sss (uint, float, ...)

	exception: if sss is a struct or array, then we get two types, the "unnamed" and "named" type.
	The unnamed type is a dwarf struct type with name "struct pkg.XXX" or a dwarf array type with
	name [N]elem.
	Then there is a typedef with pkg.XXX pointing to "struct pkg.XXX" or [N]elem.

	For structures, lowercase field names are prepended with the package name (pkg path?).

	type XXX interface{}
	pkg.XXX is a typedef to "struct runtime.eface"
	type XXX interface{f()}
	pkg.XXX is a typedef to "struct runtime.iface"

	Sometimes there is even a chain of identically-named typedefs. I have no idea why.
	main.XXX -> main.XXX -> struct runtime.iface

	*/