ogle/program/server: provide PC->source evaluation
For now, we must do this with the old Plan 9 symbol
pclntab because the DWARF stuff seems corrupt.

LGTM=nigeltao
R=nigeltao
https://golang.org/cl/86380045

program/server/server.go

diff --git a/program/server/server.go b/program/server/server.go
index 315ce2d..2835bdc 100644
--- a/program/server/server.go
+++ b/program/server/server.go
@@ -15,6 +15,8 @@
 	"sync"
 	"syscall"
 
+	"code.google.com/p/ogle/gosym"
+
 	"code.google.com/p/ogle/debug/dwarf"
 	"code.google.com/p/ogle/debug/elf"
 	"code.google.com/p/ogle/debug/macho"
@@ -33,6 +35,7 @@
 	arch       arch.Architecture
 	executable string // Name of executable.
 	dwarfData  *dwarf.Data
+	table      *gosym.Table
 
 	mu sync.Mutex
 
@@ -55,7 +58,7 @@
 		return nil, err
 	}
 	defer fd.Close()
-	architecture, dwarfData, err := loadExecutable(fd)
+	architecture, dwarfData, table, err := loadExecutable(fd)
 	if err != nil {
 		return nil, err
 	}
@@ -63,6 +66,7 @@
 		arch:        *architecture,
 		executable:  executable,
 		dwarfData:   dwarfData,
+		table:       table,
 		fc:          make(chan func() error),
 		ec:          make(chan error),
 		breakpoints: make(map[uint64]breakpoint),
@@ -71,42 +75,76 @@
 	return srv, nil
 }
 
-func loadExecutable(f *os.File) (*arch.Architecture, *dwarf.Data, error) {
+func loadExecutable(f *os.File) (*arch.Architecture, *dwarf.Data, *gosym.Table, error) {
 	// TODO: How do we detect NaCl?
 	if obj, err := elf.NewFile(f); err == nil {
 		dwarfData, err := obj.DWARF()
 		if err != nil {
-			return nil, nil, err
+			return nil, nil, nil, err
 		}
+
+		table, err := parseElf(obj)
+		if err != nil {
+			return nil, nil, nil, fmt.Errorf("parsing go symbol table: %v", err)
+		}
+
 		switch obj.Machine {
 		case elf.EM_ARM:
-			return &arch.ARM, dwarfData, nil
+			return &arch.ARM, dwarfData, table, nil
 		case elf.EM_386:
 			switch obj.Class {
 			case elf.ELFCLASS32:
-				return &arch.X86, dwarfData, nil
+				return &arch.X86, dwarfData, table, nil
 			case elf.ELFCLASS64:
-				return &arch.AMD64, dwarfData, nil
+				return &arch.AMD64, dwarfData, table, nil
 			}
 		case elf.EM_X86_64:
-			return &arch.AMD64, dwarfData, nil
+			return &arch.AMD64, dwarfData, table, nil
 		}
-		return nil, nil, fmt.Errorf("unrecognized ELF architecture")
+		return nil, nil, nil, fmt.Errorf("unrecognized ELF architecture")
 	}
 	if obj, err := macho.NewFile(f); err == nil {
 		dwarfData, err := obj.DWARF()
 		if err != nil {
-			return nil, nil, err
+			return nil, nil, nil, err
 		}
+
+		/* TODO
+		table, err := parseMachO(obj)
+		if err != nil {
+			return nil, nil, nil, err
+		}
+		*/
 		switch obj.Cpu {
 		case macho.Cpu386:
-			return &arch.X86, dwarfData, nil
+			return &arch.X86, dwarfData, nil, nil
 		case macho.CpuAmd64:
-			return &arch.AMD64, dwarfData, nil
+			return &arch.AMD64, dwarfData, nil, nil
 		}
-		return nil, nil, fmt.Errorf("unrecognized Mach-O architecture")
+		return nil, nil, nil, fmt.Errorf("unrecognized Mach-O architecture")
 	}
-	return nil, nil, fmt.Errorf("unrecognized binary format")
+	return nil, nil, nil, fmt.Errorf("unrecognized binary format")
+}
+
+// parseElf returns the gosym.Table representation of the old symbol tables.
+// TODO: Delete this once we know how to get PC/line data out of DWARF.
+func parseElf(f *elf.File) (*gosym.Table, error) {
+	symdat, err := f.Section(".gosymtab").Data() // TODO unused.
+	if err != nil {
+		return nil, err
+	}
+	pclndat, err := f.Section(".gopclntab").Data()
+	if err != nil {
+		return nil, err
+	}
+
+	pcln := gosym.NewLineTable(pclndat, f.Section(".text").Addr)
+	tab, err := gosym.NewTable(symdat, pcln)
+	if err != nil {
+		return nil, err
+	}
+
+	return tab, nil
 }
 
 type file struct {
@@ -369,6 +407,18 @@
 		}
 		return []string{fmt.Sprintf("%#x", addr)}, nil
 
+	case strings.HasPrefix(expr, "src:"):
+		// Numerical address. Return file.go:123.
+		addr, err := strconv.ParseUint(expr[4:], 0, 0)
+		if err != nil {
+			return nil, err
+		}
+		file, line, ok := s.lookupSource(addr)
+		if !ok {
+			return nil, fmt.Errorf("no PC/line data for: %q", expr)
+		}
+		return []string{fmt.Sprintf("%s:%d", file, line)}, nil
+
 	case len(expr) > 0 && '0' <= expr[0] && expr[0] <= '9':
 		// Numerical address. Return symbol.
 		addr, err := strconv.ParseUint(expr, 0, 0)
@@ -385,6 +435,14 @@
 	return nil, fmt.Errorf("bad expression syntax: %q", expr)
 }
 
+func (s *Server) lookupSource(pc uint64) (file string, line int, ok bool) {
+	if s.table == nil {
+		return
+	}
+	file, line, fn := s.table.PCToLine(pc)
+	return file, line, fn != nil
+}
+
 // evalAddress takes a simple expression, either a symbol or hex value,
 // and evaluates it as an address.
 func (s *Server) evalAddress(expr string) (uint64, error) {