diff --git a/dwarf/cache.go b/dwarf/cache.go
new file mode 100644
index 0000000..cf795e7
--- /dev/null
+++ b/dwarf/cache.go
@@ -0,0 +1,249 @@
+// Copyright 2016 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 dwarf
+
+import (
+	"sort"
+)
+
+// pcToFuncEntries maps PC ranges to function entries.
+//
+// Each element contains a *Entry for a function and its corresponding start PC.
+// If we know the address one past the last instruction of a function, and it is
+// not equal to the start address of the next function, we mark that with
+// another element containing that address and a nil entry.  The elements are
+// sorted by PC.  Among elements with the same PC, those with non-nil *Entry
+// are put earlier.
+type pcToFuncEntries []pcToFuncEntry
+type pcToFuncEntry struct {
+	pc    uint64
+	entry *Entry
+}
+
+func (p pcToFuncEntries) Len() int      { return len(p) }
+func (p pcToFuncEntries) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
+func (p pcToFuncEntries) Less(i, j int) bool {
+	if p[i].pc != p[j].pc {
+		return p[i].pc < p[j].pc
+	}
+	return p[i].entry != nil && p[j].entry == nil
+}
+
+// nameCache maps each symbol name to a linked list of the entries with that name.
+type nameCache map[string]*nameCacheEntry
+type nameCacheEntry struct {
+	entry *Entry
+	link  *nameCacheEntry
+}
+
+// pcToLineEntries maps PCs to line numbers.
+//
+// It is a slice of (PC, line, file number) triples, sorted by PC.  The file
+// number is an index into the source files slice.
+// If (PC1, line1, file1) and (PC2, line2, file2) are two consecutive elements,
+// then the span of addresses [PC1, PC2) belongs to (line1, file1).  If an
+// element's file number is zero, it only marks the end of a span.
+//
+// TODO: could save memory by changing pcToLineEntries and lineToPCEntries to use
+// interval trees containing references into .debug_line.
+type pcToLineEntries []pcToLineEntry
+type pcToLineEntry struct {
+	pc   uint64
+	line uint64
+	file uint64
+}
+
+func (p pcToLineEntries) Len() int      { return len(p) }
+func (p pcToLineEntries) Swap(i, j int) { p[i], p[j] = p[j], p[i] }
+func (p pcToLineEntries) Less(i, j int) bool {
+	if p[i].pc != p[j].pc {
+		return p[i].pc < p[j].pc
+	}
+	return p[i].file > p[j].file
+}
+
+// byFileLine is used temporarily while building lineToPCEntries.
+type byFileLine []pcToLineEntry
+
+func (b byFileLine) Len() int      { return len(b) }
+func (b byFileLine) Swap(i, j int) { b[i], b[j] = b[j], b[i] }
+func (b byFileLine) Less(i, j int) bool {
+	if b[i].file != b[j].file {
+		return b[i].file < b[j].file
+	}
+	return b[i].line < b[j].line
+}
+
+// lineToPCEntries maps line numbers to breakpoint addresses.
+//
+// The slice contains, for each source file in Data, a slice of (line, PC)
+// pairs, sorted by line.  Note that there may be more than one PC for a line.
+type lineToPCEntries [][]lineToPCEntry
+type lineToPCEntry struct {
+	line uint64
+	pc   uint64
+}
+
+func (d *Data) buildLineToPCCache(pclfs pcToLineEntries) {
+	// TODO: only include lines where is_stmt is true
+	sort.Sort(byFileLine(pclfs))
+	// Make a slice of (line, PC) pairs for each (non-zero) file.
+	var (
+		c        = make(lineToPCEntries, len(d.sourceFiles))
+		curSlice []lineToPCEntry
+	)
+	for i, pclf := range pclfs {
+		if pclf.file == 0 {
+			// This entry indicated the end of an instruction sequence, not a breakpoint.
+			continue
+		}
+		curSlice = append(curSlice, lineToPCEntry{line: pclf.line, pc: pclf.pc})
+		if i+1 == len(pclfs) || pclf.file != pclfs[i+1].file {
+			// curSlice now contains all of the entries for pclf.file.
+			if pclf.file > 0 && pclf.file < uint64(len(c)) {
+				c[pclf.file] = curSlice
+			}
+			curSlice = nil
+		}
+	}
+	d.lineToPCEntries = c
+}
+
+func (d *Data) buildPCToLineCache(cache pcToLineEntries) {
+	// Sort cache by PC (in increasing order), then by file number (in decreasing order).
+	sort.Sort(cache)
+
+	// Build a copy without redundant entries.
+	var out pcToLineEntries
+	for i, pclf := range cache {
+		if i > 0 && pclf.pc == cache[i-1].pc {
+			// This entry is for the same PC as the previous entry.
+			continue
+		}
+		if i > 0 && pclf.file == cache[i-1].file && pclf.line == cache[i-1].line {
+			// This entry is for the same file and line as the previous entry.
+			continue
+		}
+		out = append(out, pclf)
+	}
+	d.pcToLineEntries = out
+}
+
+// buildLineCaches constructs d.sourceFiles, d.lineToPCEntries, d.pcToLineEntries.
+func (d *Data) buildLineCaches() {
+	if len(d.line) == 0 {
+		return
+	}
+	var m lineMachine
+	// Assume the address_size in the first unit applies to the whole program.
+	// TODO: we could handle executables containing code for multiple address
+	// sizes using DW_AT_stmt_list attributes.
+	if len(d.unit) == 0 {
+		return
+	}
+	buf := makeBuf(d, &d.unit[0], "line", 0, d.line)
+	if err := m.parseHeader(&buf); err != nil {
+		return
+	}
+	for _, f := range m.header.file {
+		d.sourceFiles = append(d.sourceFiles, f.name)
+	}
+	var cache pcToLineEntries
+	fn := func(m *lineMachine) bool {
+		if m.endSequence {
+			cache = append(cache, pcToLineEntry{
+				pc:   m.address,
+				line: 0,
+				file: 0,
+			})
+		} else {
+			cache = append(cache, pcToLineEntry{
+				pc:   m.address,
+				line: m.line,
+				file: m.file,
+			})
+		}
+		return true
+	}
+	m.evalCompilationUnit(&buf, fn)
+	d.buildLineToPCCache(cache)
+	d.buildPCToLineCache(cache)
+}
+
+// buildInfoCaches initializes nameCache and pcToFuncEntries by walking the
+// top-level entries under each compile unit. It swallows any errors in parsing.
+func (d *Data) buildInfoCaches() {
+	// TODO: record errors somewhere?
+	d.nameCache = make(map[string]*nameCacheEntry)
+
+	var pcToFuncEntries pcToFuncEntries
+
+	r := d.Reader()
+loop:
+	for {
+		entry, err := r.Next()
+		if entry == nil || err != nil {
+			break loop
+		}
+		if entry.Tag != TagCompileUnit /* DW_TAG_compile_unit */ {
+			r.SkipChildren()
+			continue
+		}
+		for {
+			entry, err := r.Next()
+			if entry == nil || err != nil {
+				break loop
+			}
+			if entry.Tag == 0 {
+				// End of children of current compile unit.
+				break
+			}
+			r.SkipChildren()
+			// Update name-to-entry cache.
+			if name, ok := entry.Val(AttrName).(string); ok {
+				d.nameCache[name] = &nameCacheEntry{entry: entry, link: d.nameCache[name]}
+			}
+
+			// If this entry is a function, update PC-to-containing-function cache.
+			if entry.Tag != TagSubprogram /* DW_TAG_subprogram */ {
+				continue
+			}
+
+			// DW_AT_low_pc, if present, is the address of the first instruction of
+			// the function.
+			lowpc, ok := entry.Val(AttrLowpc).(uint64)
+			if !ok {
+				continue
+			}
+			pcToFuncEntries = append(pcToFuncEntries, pcToFuncEntry{lowpc, entry})
+
+			// DW_AT_high_pc, if present (TODO: and of class address) is the address
+			// one past the last instruction of the function.
+			highpc, ok := entry.Val(AttrHighpc).(uint64)
+			if !ok {
+				continue
+			}
+			pcToFuncEntries = append(pcToFuncEntries, pcToFuncEntry{highpc, nil})
+		}
+	}
+	// Sort elements by PC.  If there are multiple elements with the same PC,
+	// those with non-nil *Entry are placed earlier.
+	sort.Sort(pcToFuncEntries)
+
+	// Copy only the first element for each PC to out.
+	n := 0
+	for i, ce := range pcToFuncEntries {
+		if i == 0 || ce.pc != pcToFuncEntries[i-1].pc {
+			n++
+		}
+	}
+	out := make([]pcToFuncEntry, 0, n)
+	for i, ce := range pcToFuncEntries {
+		if i == 0 || ce.pc != pcToFuncEntries[i-1].pc {
+			out = append(out, ce)
+		}
+	}
+	d.pcToFuncEntries = out
+}
diff --git a/dwarf/line.go b/dwarf/line.go
index f035ef9..2f47739 100644
--- a/dwarf/line.go
+++ b/dwarf/line.go
@@ -11,91 +11,40 @@
 
 import (
 	"fmt"
+	"sort"
 	"strings"
 )
 
 // PCToLine returns the file and line number corresponding to the PC value.
 // It returns an error if a correspondence cannot be found.
 func (d *Data) PCToLine(pc uint64) (file string, line uint64, err error) {
-	if len(d.line) == 0 {
+	c := d.pcToLineEntries
+	if len(c) == 0 {
 		return "", 0, fmt.Errorf("PCToLine: no line table")
 	}
-	var m lineMachine
-	// Assume the first info unit is the same as us. Extremely likely. TODO?
-	if len(d.unit) == 0 {
-		return "", 0, fmt.Errorf("no info section")
-	}
-	buf := makeBuf(d, &d.unit[0], "line", 0, d.line)
-	if err = m.parseHeader(&buf); err != nil {
-		return "", 0, err
-	}
-	state := pcSearchState{pc: pc, newSequence: true}
-	if err = m.evalCompilationUnit(&buf, state.findPC); err != nil {
-		return "", 0, err
-	}
-	if !state.found {
+	i := sort.Search(len(c), func(i int) bool { return c[i].pc > pc }) - 1
+	// c[i] is now the entry in pcToLineEntries with the largest pc that is not
+	// larger than the query pc.
+	// The search has failed if:
+	// - All pcs in c were larger than the query pc (i == -1).
+	// - c[i] marked the end of a sequence of instructions (c[i].file == 0).
+	// - c[i] is the last element of c, and isn't the end of a sequence of
+	//   instructions, and the search pc is much larger than c[i].pc.  In this
+	//   case, we don't know the range of the last instruction, but the search
+	//   pc is probably past it.
+	if i == -1 || c[i].file == 0 || (i+1 == len(c) && pc-c[i].pc > 1024) {
 		return "", 0, fmt.Errorf("no source line defined for PC %#x", pc)
 	}
-	if state.lastFile >= uint64(len(m.header.file)) {
+	if c[i].file >= uint64(len(d.sourceFiles)) {
 		return "", 0, fmt.Errorf("invalid file number in DWARF data")
 	}
-	return m.header.file[state.lastFile].name, state.lastLine, nil
+	return d.sourceFiles[c[i].file], c[i].line, nil
 }
 
-// pcSearchState holds the state for the search PCToLine does.
-type pcSearchState struct {
-	pc uint64 // pc we are searching for.
-	// lastPC, lastFile, and lastLine are the PC, file number and line that were
-	// output most recently by the line machine.
-	lastPC   uint64
-	lastFile uint64
-	lastLine uint64
-	// found indicates that the above values correspond to the PC we're looking for.
-	found bool
-	// newSequence indicates that we are starting a new sequence of instructions,
-	// and so last{PC,File,Line} are not valid.
-	newSequence bool
-}
-
-// findPC will execute for every line in the state machine, until we find state.pc.
-// It returns a bool indicating whether to continue searching.
-func (state *pcSearchState) findPC(m *lineMachine) bool {
-	if !state.newSequence && state.lastPC < state.pc && state.pc < m.address {
-		// The PC we are looking for is between the previous PC and the current PC,
-		// so lastFile and lastLine are its source location.
-		state.found = true
-		return false
-	}
-	if m.endSequence {
-		state.newSequence = true
-		return true
-	}
-	state.newSequence = false
-	state.lastPC, state.lastFile, state.lastLine = m.address, m.file, m.line
-	if m.address == state.pc {
-		// lastFile and lastLine are the source location of pc.
-		state.found = true
-		return false
-	}
-	return true
-}
-
-// LineToPCs returns the PCs corresponding to the file and line number.
+// LineToBreakpointPCs returns the PCs that should be used as breakpoints
+// corresponding to the given file and line number.
 // It returns an empty slice if no PCs were found.
-func (d *Data) LineToPCs(file string, line uint64) ([]uint64, error) {
-	if len(d.line) == 0 {
-		return nil, fmt.Errorf("LineToPCs: no line table")
-	}
-	if len(d.unit) == 0 {
-		return nil, fmt.Errorf("LineToPCs: no info section")
-	}
-
-	buf := makeBuf(d, &d.unit[0], "line", 0, d.line)
-	var m lineMachine
-	if err := m.parseHeader(&buf); err != nil {
-		return nil, err
-	}
-
+func (d *Data) LineToBreakpointPCs(file string, line uint64) ([]uint64, error) {
 	compDir := d.compilationDirectory()
 
 	// Find the closest match in the executable for the specified file.
@@ -103,46 +52,43 @@
 	// at the end of the name. If there is a tie, we prefer files that are
 	// under the compilation directory.  If there is still a tie, we choose
 	// the file with the shortest name.
+	// TODO: handle duplicate file names in the DWARF?
 	var bestFile struct {
 		fileNum    uint64 // Index of the file in the DWARF data.
 		components int    // Number of matching path components.
 		length     int    // Length of the filename.
 		underComp  bool   // File is under the compilation directory.
 	}
-	for num, f := range m.header.file {
-		c := matchingPathComponentSuffixSize(f.name, file)
-		underComp := strings.HasPrefix(f.name, compDir)
+	for filenum, filename := range d.sourceFiles {
+		c := matchingPathComponentSuffixSize(filename, file)
+		underComp := strings.HasPrefix(filename, compDir)
 		better := false
 		if c != bestFile.components {
 			better = c > bestFile.components
 		} else if underComp != bestFile.underComp {
 			better = underComp
 		} else {
-			better = len(f.name) < bestFile.length
+			better = len(filename) < bestFile.length
 		}
 		if better {
-			bestFile.fileNum = uint64(num)
+			bestFile.fileNum = uint64(filenum)
 			bestFile.components = c
-			bestFile.length = len(f.name)
+			bestFile.length = len(filename)
 			bestFile.underComp = underComp
 		}
 	}
 	if bestFile.components == 0 {
-		return nil, fmt.Errorf("couldn't find file %s", file)
+		return nil, fmt.Errorf("couldn't find file %q", file)
 	}
 
-	// pcs will contain the PCs for every line machine output with the correct line
-	// and file number.
-	var pcs []uint64
-	// accumulatePCs will execute for every line machine output.
-	accumulatePCs := func(m *lineMachine) (cont bool) {
-		if m.line == line && m.file == bestFile.fileNum {
-			pcs = append(pcs, m.address)
-		}
-		return true
-	}
-	if err := m.evalCompilationUnit(&buf, accumulatePCs); err != nil {
-		return nil, err
+	c := d.lineToPCEntries[bestFile.fileNum]
+	// c contains all (pc, line) pairs for the appropriate file.
+	start := sort.Search(len(c), func(i int) bool { return c[i].line >= line })
+	end := sort.Search(len(c), func(i int) bool { return c[i].line > line })
+	// c[i].line == line for all i in the range [start, end).
+	pcs := make([]uint64, 0, end-start)
+	for i := start; i < end; i++ {
+		pcs = append(pcs, c[i].pc)
 	}
 	return pcs, nil
 }
diff --git a/dwarf/open.go b/dwarf/open.go
index 488bbf0..a13c6ed 100644
--- a/dwarf/open.go
+++ b/dwarf/open.go
@@ -23,11 +23,16 @@
 	str      []byte
 
 	// parsed data
-	abbrevCache map[uint32]abbrevTable
-	order       binary.ByteOrder
-	typeCache   map[Offset]Type
-	typeSigs    map[uint64]*typeUnit
-	unit        []unit
+	abbrevCache     map[uint32]abbrevTable
+	order           binary.ByteOrder
+	typeCache       map[Offset]Type
+	typeSigs        map[uint64]*typeUnit
+	unit            []unit
+	sourceFiles     []string // source files listed in .debug_line.
+	nameCache                // map from name to top-level entries in .debug_info.
+	pcToFuncEntries          // cache of .debug_info data for function bounds.
+	pcToLineEntries          // cache of .debug_line data, used for efficient PC-to-line mapping.
+	lineToPCEntries          // cache of .debug_line data, used for efficient line-to-[]PC mapping.
 }
 
 // New returns a new Data object initialized from the given parameters.
@@ -75,6 +80,8 @@
 		return nil, err
 	}
 	d.unit = u
+	d.buildInfoCaches()
+	d.buildLineCaches()
 	return d, nil
 }
 
diff --git a/dwarf/symbol.go b/dwarf/symbol.go
index 6ddc836..52d6829 100644
--- a/dwarf/symbol.go
+++ b/dwarf/symbol.go
@@ -6,33 +6,36 @@
 
 // This file provides simple methods to access the symbol table by name and address.
 
-import "fmt"
+import (
+	"fmt"
+	"regexp"
+	"sort"
+)
 
-// lookupEntry returns the Entry for the name. If tag is non-zero, only entries
-// with that tag are considered.
+// lookupEntry returns the first Entry for the name.
+// If tag is non-zero, only entries with that tag are considered.
 func (d *Data) lookupEntry(name string, tag Tag) (*Entry, error) {
-	r := d.Reader()
-	for {
-		entry, err := r.Next()
-		if err != nil {
-			return nil, err
-		}
-		if entry == nil {
-			// TODO: why don't we get an error here?
-			break
-		}
-		if tag != 0 && tag != entry.Tag {
-			continue
-		}
-		nameAttr := entry.Val(AttrName)
-		if nameAttr == nil {
-			continue
-		}
-		if nameAttr.(string) == name {
-			return entry, nil
+	x, ok := d.nameCache[name]
+	if !ok {
+		return nil, fmt.Errorf("DWARF entry for %q not found", name)
+	}
+	for ; x != nil; x = x.link {
+		if tag == 0 || x.entry.Tag == tag {
+			return x.entry, nil
 		}
 	}
-	return nil, fmt.Errorf("DWARF entry for %q not found", name)
+	return nil, fmt.Errorf("no DWARF entry for %q with tag %s", name, tag)
+}
+
+// LookupMatchingSymbols returns the names of all top-level entries matching
+// the given regular expression.
+func (d *Data) LookupMatchingSymbols(nameRE *regexp.Regexp) (result []string, err error) {
+	for name := range d.nameCache {
+		if nameRE.MatchString(name) {
+			result = append(result, name)
+		}
+	}
+	return result, nil
 }
 
 // LookupEntry returns the Entry for the named symbol.
@@ -40,38 +43,14 @@
 	return d.lookupEntry(name, 0)
 }
 
-// LookupFunction returns the address of the named symbol, a function.
-func (d *Data) LookupFunction(name string) (uint64, error) {
-	entry, err := d.lookupEntry(name, TagSubprogram)
-	if err != nil {
-		return 0, err
-	}
-	addrAttr := entry.Val(AttrLowpc)
-	if addrAttr == nil {
-		return 0, fmt.Errorf("symbol %q has no LowPC attribute", name)
-	}
-	addr, ok := addrAttr.(uint64)
-	if !ok {
-		return 0, fmt.Errorf("symbol %q has non-uint64 LowPC attribute", name)
-	}
-	return addr, nil
+// LookupFunction returns the entry for a function.
+func (d *Data) LookupFunction(name string) (*Entry, error) {
+	return d.lookupEntry(name, TagSubprogram)
 }
 
-// TODO: should LookupVariable handle both globals and locals? Locals don't
-// necessarily have a fixed address. They may be in a register, or otherwise
-// move around.
-
-// LookupVariable returns the location of a named symbol, a variable.
-func (d *Data) LookupVariable(name string) (uint64, error) {
-	entry, err := d.lookupEntry(name, TagVariable)
-	if err != nil {
-		return 0, fmt.Errorf("variable %s: %s", name, err)
-	}
-	loc, err := d.EntryLocation(entry)
-	if err != nil {
-		return 0, fmt.Errorf("variable %s: %s", name, err)
-	}
-	return loc, nil
+// LookupVariable returns the entry for a (global) variable.
+func (d *Data) LookupVariable(name string) (*Entry, error) {
+	return d.lookupEntry(name, TagVariable)
 }
 
 // EntryLocation returns the address of the object referred to by the given Entry.
@@ -97,6 +76,15 @@
 	return 0, fmt.Errorf("DWARF entry has an unimplemented Location op")
 }
 
+// EntryType returns the Type for an Entry.
+func (d *Data) EntryType(e *Entry) (Type, error) {
+	off, err := d.EntryTypeOffset(e)
+	if err != nil {
+		return nil, err
+	}
+	return d.Type(off)
+}
+
 // EntryTypeOffset returns the offset in the given Entry's type attribute.
 func (d *Data) EntryTypeOffset(e *Entry) (Offset, error) {
 	v := e.Val(AttrType)
@@ -110,46 +98,22 @@
 	return off, nil
 }
 
-// LookupPC returns the name of a symbol at the specified PC.
-func (d *Data) LookupPC(pc uint64) (string, error) {
-	entry, _, err := d.EntryForPC(pc)
-	if err != nil {
-		return "", err
+// PCToFunction returns the entry and address for the function containing the
+// specified PC.
+func (d *Data) PCToFunction(pc uint64) (entry *Entry, lowpc uint64, err error) {
+	p := d.pcToFuncEntries
+	if len(p) == 0 {
+		return nil, 0, fmt.Errorf("no function addresses loaded")
 	}
-	nameAttr := entry.Val(AttrName)
-	if nameAttr == nil {
-		// TODO: this shouldn't be possible.
-		return "", fmt.Errorf("LookupPC: TODO")
+	i := sort.Search(len(p), func(i int) bool { return p[i].pc > pc }) - 1
+	// The search failed if:
+	// - pc was before the start of any function.
+	// - The largest function bound not larger than pc was the end of a function,
+	//   not the start of one.
+	// - The largest function bound not larger than pc was the start of a function
+	//   that we don't know the end of, and the PC is much larger than the start.
+	if i == -1 || p[i].entry == nil || (i+1 == len(p) && pc-p[i].pc >= 1<<20) {
+		return nil, 0, fmt.Errorf("no function at %x", pc)
 	}
-	name, ok := nameAttr.(string)
-	if !ok {
-		return "", fmt.Errorf("name for PC %#x is not a string", pc)
-	}
-	return name, nil
-}
-
-// EntryForPC returns the entry and address for a symbol at the specified PC.
-func (d *Data) EntryForPC(pc uint64) (entry *Entry, lowpc uint64, err error) {
-	// TODO: do something better than a linear scan?
-	r := d.Reader()
-	for {
-		entry, err := r.Next()
-		if err != nil {
-			return nil, 0, err
-		}
-		if entry == nil {
-			// TODO: why don't we get an error here.
-			break
-		}
-		if entry.Tag != TagSubprogram {
-			continue
-		}
-		lowpc, lok := entry.Val(AttrLowpc).(uint64)
-		highpc, hok := entry.Val(AttrHighpc).(uint64)
-		if !lok || !hok || pc < lowpc || highpc <= pc {
-			continue
-		}
-		return entry, lowpc, nil
-	}
-	return nil, 0, fmt.Errorf("PC %#x not found", pc)
+	return p[i].entry, p[i].pc, nil
 }
diff --git a/server/dwarf.go b/server/dwarf.go
index 50f2220..3c4e2a2 100644
--- a/server/dwarf.go
+++ b/server/dwarf.go
@@ -6,50 +6,25 @@
 
 import (
 	"errors"
-	"regexp"
+	"fmt"
 
 	"golang.org/x/debug/dwarf"
 )
 
-func (s *Server) lookupRE(re *regexp.Regexp) (result []string, err error) {
-	r := s.dwarfData.Reader()
-	for {
-		entry, err := r.Next()
-		if err != nil {
-			return nil, err
-		}
-		if entry == nil {
-			// TODO: why don't we get an error here.
-			break
-		}
-		nameAttr := entry.Val(dwarf.AttrName)
-		if nameAttr == nil {
-			// TODO: this shouldn't be possible.
-			continue
-		}
-		name, ok := nameAttr.(string)
-		if !ok || !re.MatchString(name) {
-			continue
-		}
-		result = append(result, name)
+func (s *Server) functionStartAddress(name string) (uint64, error) {
+	entry, err := s.dwarfData.LookupFunction(name)
+	if err != nil {
+		return 0, err
 	}
-	return result, nil
-}
-
-func (s *Server) lookupFunction(name string) (uint64, error) {
-	return s.dwarfData.LookupFunction(name)
-}
-
-func (s *Server) lookupVariable(name string) (uint64, error) {
-	return s.dwarfData.LookupVariable(name)
-}
-
-func (s *Server) lookupPC(pc uint64) (string, error) {
-	return s.dwarfData.LookupPC(pc)
-}
-
-func (s *Server) entryForPC(pc uint64) (entry *dwarf.Entry, lowpc uint64, err error) {
-	return s.dwarfData.EntryForPC(pc)
+	addrAttr := entry.Val(dwarf.AttrLowpc)
+	if addrAttr == nil {
+		return 0, fmt.Errorf("symbol %q has no LowPC attribute", name)
+	}
+	addr, ok := addrAttr.(uint64)
+	if !ok {
+		return 0, fmt.Errorf("symbol %q has non-uint64 LowPC attribute", name)
+	}
+	return addr, nil
 }
 
 // evalLocation parses a DWARF location description encoded in v.  It works for
diff --git a/server/eval.go b/server/eval.go
index b7a1b68..d964a32 100644
--- a/server/eval.go
+++ b/server/eval.go
@@ -1565,7 +1565,7 @@
 // The PC and SP are used to determine the current function and stack frame.
 func (s *Server) findLocalVar(name string, pc, sp uint64) (uint64, dwarf.Type) {
 	// Find the DWARF entry for the function at pc.
-	funcEntry, _, err := s.entryForPC(uint64(pc))
+	funcEntry, _, err := s.dwarfData.PCToFunction(uint64(pc))
 	if err != nil {
 		return 0, nil
 	}
@@ -1633,7 +1633,7 @@
 // findGlobalVar finds a global variable by name, and returns its address and
 // DWARF type.  It returns a nil type on failure.
 func (s *Server) findGlobalVar(name string) (uint64, dwarf.Type) {
-	entry, err := s.dwarfData.LookupEntry(name)
+	entry, err := s.dwarfData.LookupVariable(name)
 	if err != nil {
 		return 0, nil
 	}
diff --git a/server/eval.m4 b/server/eval.m4
index 0e0def3..7b7594a 100644
--- a/server/eval.m4
+++ b/server/eval.m4
@@ -1173,7 +1173,7 @@
 // The PC and SP are used to determine the current function and stack frame.
 func (s *Server) findLocalVar(name string, pc, sp uint64) (uint64, dwarf.Type) {
 	// Find the DWARF entry for the function at pc.
-	funcEntry, _, err := s.entryForPC(uint64(pc))
+	funcEntry, _, err := s.dwarfData.PCToFunction(uint64(pc))
 	if err != nil {
 		return 0, nil
 	}
@@ -1241,7 +1241,7 @@
 // findGlobalVar finds a global variable by name, and returns its address and
 // DWARF type.  It returns a nil type on failure.
 func (s *Server) findGlobalVar(name string) (uint64, dwarf.Type) {
-	entry, err := s.dwarfData.LookupEntry(name)
+	entry, err := s.dwarfData.LookupVariable(name)
 	if err != nil {
 		return 0, nil
 	}
diff --git a/server/server.go b/server/server.go
index 640895e..76219db 100644
--- a/server/server.go
+++ b/server/server.go
@@ -425,7 +425,7 @@
 }
 
 func (s *Server) handleBreakpointAtFunction(req *protocol.BreakpointAtFunctionRequest, resp *protocol.BreakpointResponse) error {
-	pc, err := s.lookupFunction(req.Function)
+	pc, err := s.functionStartAddress(req.Function)
 	if err != nil {
 		return err
 	}
@@ -440,7 +440,7 @@
 	if s.dwarfData == nil {
 		return fmt.Errorf("no DWARF data")
 	}
-	if pcs, err := s.dwarfData.LineToPCs(req.File, req.Line); err != nil {
+	if pcs, err := s.dwarfData.LineToBreakpointPCs(req.File, req.Line); err != nil {
 		return err
 	} else {
 		return s.addBreakpoints(pcs, resp)
@@ -520,11 +520,11 @@
 		if err != nil {
 			return nil, err
 		}
-		return s.lookupRE(re)
+		return s.dwarfData.LookupMatchingSymbols(re)
 
 	case strings.HasPrefix(expr, "addr:"):
 		// Symbol lookup. Return address.
-		addr, err := s.lookupFunction(expr[5:])
+		addr, err := s.functionStartAddress(expr[5:])
 		if err != nil {
 			return nil, err
 		}
@@ -556,11 +556,15 @@
 		if err != nil {
 			return nil, err
 		}
-		funcName, err := s.lookupPC(addr)
+		entry, _, err := s.dwarfData.PCToFunction(addr)
 		if err != nil {
 			return nil, err
 		}
-		return []string{funcName}, nil
+		name, ok := entry.Val(dwarf.AttrName).(string)
+		if !ok {
+			return nil, fmt.Errorf("function at 0x%x has no name", addr)
+		}
+		return []string{name}, nil
 	}
 
 	return nil, fmt.Errorf("bad expression syntax: %q", expr)
@@ -584,24 +588,6 @@
 	return s.dwarfData.PCToLine(pc)
 }
 
-// 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) {
-	// Might be a symbol.
-	addr, err := s.lookupFunction(expr) // TODO: might not be a function
-	if err == nil {
-		return addr, nil
-	}
-
-	// Must be a number.
-	addr, err = strconv.ParseUint(expr, 0, 0)
-	if err != nil {
-		return 0, fmt.Errorf("eval: %q is neither symbol nor number", expr)
-	}
-
-	return addr, nil
-}
-
 func (s *Server) Frames(req *protocol.FramesRequest, resp *protocol.FramesResponse) error {
 	return s.call(s.otherc, req, resp)
 }
@@ -643,7 +629,7 @@
 			return frames, err
 		}
 		fp := sp + uint64(fpOffset)
-		entry, funcEntry, err := s.entryForPC(pc)
+		entry, funcEntry, err := s.dwarfData.PCToFunction(pc)
 		if err != nil {
 			return frames, err
 		}
@@ -720,9 +706,9 @@
 		indirect bool
 		names    []string
 	)
-	if _, err := s.lookupVariable("runtime.rt0_goPC"); err != nil {
+	if _, err := s.dwarfData.LookupVariable("runtime.rt0_goPC"); err != nil {
 		// Look for a Go 1.3 binary (or earlier version).
-		lookup, indirect, names = s.lookupFunction, false, []string{
+		lookup, indirect, names = s.functionStartAddress, false, []string{
 			"runtime.goexit",
 			"runtime.mstart",
 			"runtime.mcall",
@@ -732,7 +718,14 @@
 		}
 	} else {
 		// Look for a Go 1.4 binary (or later version).
-		lookup, indirect, names = s.lookupVariable, true, []string{
+		lookup = func(name string) (uint64, error) {
+			entry, err := s.dwarfData.LookupVariable(name)
+			if err != nil {
+				return 0, err
+			}
+			return s.dwarfData.EntryLocation(entry)
+		}
+		indirect, names = true, []string{
 			"runtime.goexitPC",
 			"runtime.mstartPC",
 			"runtime.mcallPC",
@@ -780,7 +773,7 @@
 }
 
 func (s *Server) handleVarByName(req *protocol.VarByNameRequest, resp *protocol.VarByNameResponse) error {
-	entry, err := s.dwarfData.LookupEntry(req.Name)
+	entry, err := s.dwarfData.LookupVariable(req.Name)
 	if err != nil {
 		return fmt.Errorf("variable %s: %s", req.Name, err)
 	}
@@ -915,7 +908,7 @@
 	)
 	for {
 		// Try to read the slice runtime.allgs.
-		allgsEntry, err := s.dwarfData.LookupEntry("runtime.allgs")
+		allgsEntry, err := s.dwarfData.LookupVariable("runtime.allgs")
 		if err != nil {
 			break
 		}
@@ -945,7 +938,7 @@
 	}
 	if !allgPtrOk {
 		// Read runtime.allg.
-		allgEntry, err := s.dwarfData.LookupEntry("runtime.allg")
+		allgEntry, err := s.dwarfData.LookupVariable("runtime.allg")
 		if err != nil {
 			return err
 		}
@@ -959,7 +952,7 @@
 		}
 
 		// Read runtime.allglen.
-		allglenEntry, err := s.dwarfData.LookupEntry("runtime.allglen")
+		allglenEntry, err := s.dwarfData.LookupVariable("runtime.allglen")
 		if err != nil {
 			return err
 		}
@@ -1056,7 +1049,7 @@
 		// Best-effort attempt to get the names of the goroutine function and the
 		// function that created the goroutine.  They aren't always available.
 		functionName := func(pc uint64) string {
-			entry, _, err := s.dwarfData.EntryForPC(pc)
+			entry, _, err := s.dwarfData.PCToFunction(pc)
 			if err != nil {
 				return ""
 			}