diff --git a/program/server/dwarf.go b/program/server/dwarf.go
new file mode 100644
index 0000000..44321bc
--- /dev/null
+++ b/program/server/dwarf.go
@@ -0,0 +1,164 @@
+// Copyright 2014 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 server
+
+import (
+	"fmt"
+	"regexp"
+
+	"code.google.com/p/ogle/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
+		}
+		if entry.Tag != dwarf.TagSubprogram {
+			continue
+		}
+		nameAttr := lookupAttr(entry, 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)
+	}
+	return result, nil
+}
+
+func (s *Server) lookupSym(name string) (uint64, error) {
+	r := s.dwarfData.Reader()
+	for {
+		entry, err := r.Next()
+		if err != nil {
+			return 0, err
+		}
+		if entry == nil {
+			// TODO: why don't we get an error here.
+			break
+		}
+		if entry.Tag != dwarf.TagSubprogram {
+			continue
+		}
+		nameAttr := lookupAttr(entry, dwarf.AttrName)
+		if nameAttr == nil {
+			// TODO: this shouldn't be possible.
+			continue
+		}
+		if nameAttr.(string) != name {
+			continue
+		}
+		addrAttr := lookupAttr(entry, 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
+	}
+	return 0, fmt.Errorf("symbol %q not found", name)
+}
+
+func (s *Server) lookupPC(pc uint64) (string, error) {
+	r := s.dwarfData.Reader()
+	for {
+		entry, err := r.Next()
+		if err != nil {
+			return "", err
+		}
+		if entry == nil {
+			// TODO: why don't we get an error here.
+			break
+		}
+		if entry.Tag != dwarf.TagSubprogram {
+			continue
+		}
+		lowpc, lok := lookupAttr(entry, dwarf.AttrLowpc).(uint64)
+		highpc, hok := lookupAttr(entry, dwarf.AttrHighpc).(uint64)
+		if !lok || !hok || pc < lowpc || highpc <= pc {
+			continue
+		}
+		nameAttr := lookupAttr(entry, dwarf.AttrName)
+		if nameAttr == nil {
+			// TODO: this shouldn't be possible.
+			continue
+		}
+		name, ok := nameAttr.(string)
+		if !ok {
+			return "", fmt.Errorf("name for PC %#x is not a string", pc)
+		}
+		return name, nil
+	}
+	return "", fmt.Errorf("PC %#x not found", pc)
+}
+
+func lookupAttr(e *dwarf.Entry, a dwarf.Attr) interface{} {
+	for _, f := range e.Field {
+		if f.Attr == a {
+			return f.Val
+		}
+	}
+	return nil
+}
+
+func evalLocation(v []uint8) string {
+	if len(v) == 0 {
+		return "<nil>"
+	}
+	if v[0] != 0x9C { // DW_OP_call_frame_cfa
+		return "UNK0"
+	}
+	if len(v) == 1 {
+		return "0"
+	}
+	v = v[1:]
+	if v[0] != 0x11 { // DW_OP_consts
+		return "UNK1"
+	}
+	return fmt.Sprintf("%x", sleb128(v[1:]))
+}
+
+func uleb128(v []uint8) (u uint64) {
+	var shift uint
+	for _, x := range v {
+		u |= (uint64(x) & 0x7F) << shift
+		shift += 7
+		if x&0x80 == 0 {
+			break
+		}
+	}
+	return u
+}
+
+func sleb128(v []uint8) (s int64) {
+	var shift uint
+	var sign int64 = -1
+	for _, x := range v {
+		s |= (int64(x) & 0x7F) << shift
+		shift += 7
+		sign <<= 7
+		if x&0x80 == 0 {
+			if x&0x40 != 0 {
+				s |= sign
+			}
+			break
+		}
+	}
+	// Sign extend?
+	return s
+}
diff --git a/program/server/server.go b/program/server/server.go
index d08ed47..372d172 100644
--- a/program/server/server.go
+++ b/program/server/server.go
@@ -15,11 +15,10 @@
 	"sync"
 	"syscall"
 
-	"debug/elf"
-	"debug/macho"
-	"debug/pe"
+	"code.google.com/p/ogle/debug/dwarf"
+	"code.google.com/p/ogle/debug/elf"
+	"code.google.com/p/ogle/debug/macho"
 
-	"code.google.com/p/ogle/gosym"
 	"code.google.com/p/ogle/program"
 	"code.google.com/p/ogle/program/proxyrpc"
 )
@@ -31,8 +30,7 @@
 
 type Server struct {
 	executable string // Name of executable.
-	lines      *gosym.LineTable
-	symbols    *gosym.Table
+	dwarfData  *dwarf.Data
 
 	mu sync.Mutex
 
@@ -52,19 +50,13 @@
 		return nil, err
 	}
 	defer fd.Close()
-	textStart, symtab, pclntab, err := loadTables(fd)
-	if err != nil {
-		return nil, err
-	}
-	lines := gosym.NewLineTable(pclntab, textStart)
-	symbols, err := gosym.NewTable(symtab, lines)
+	dwarfData, err := loadDwarfData(fd)
 	if err != nil {
 		return nil, err
 	}
 	srv := &Server{
 		executable:  executable,
-		lines:       lines,
-		symbols:     symbols,
+		dwarfData:   dwarfData,
 		fc:          make(chan func() error),
 		ec:          make(chan error),
 		breakpoints: make(map[uint64]breakpoint),
@@ -73,62 +65,14 @@
 	return srv, nil
 }
 
-// This function is copied from $GOROOT/src/cmd/addr2line/main.go.
-// TODO: Make this architecture-defined? Push into gosym?
-// TODO: Why is the .gosymtab always empty?
-func loadTables(f *os.File) (textStart uint64, symtab, pclntab []byte, err error) {
+func loadDwarfData(f *os.File) (*dwarf.Data, error) {
 	if obj, err := elf.NewFile(f); err == nil {
-		if sect := obj.Section(".text"); sect != nil {
-			textStart = sect.Addr
-		}
-		if sect := obj.Section(".gosymtab"); sect != nil {
-			if symtab, err = sect.Data(); err != nil {
-				return 0, nil, nil, err
-			}
-		}
-		if sect := obj.Section(".gopclntab"); sect != nil {
-			if pclntab, err = sect.Data(); err != nil {
-				return 0, nil, nil, err
-			}
-		}
-		return textStart, symtab, pclntab, nil
+		return obj.DWARF()
 	}
-
 	if obj, err := macho.NewFile(f); err == nil {
-		if sect := obj.Section("__text"); sect != nil {
-			textStart = sect.Addr
-		}
-		if sect := obj.Section("__gosymtab"); sect != nil {
-			if symtab, err = sect.Data(); err != nil {
-				return 0, nil, nil, err
-			}
-		}
-		if sect := obj.Section("__gopclntab"); sect != nil {
-			if pclntab, err = sect.Data(); err != nil {
-				return 0, nil, nil, err
-			}
-		}
-		return textStart, symtab, pclntab, nil
+		return obj.DWARF()
 	}
-
-	if obj, err := pe.NewFile(f); err == nil {
-		if sect := obj.Section(".text"); sect != nil {
-			textStart = uint64(sect.VirtualAddress)
-		}
-		if sect := obj.Section(".gosymtab"); sect != nil {
-			if symtab, err = sect.Data(); err != nil {
-				return 0, nil, nil, err
-			}
-		}
-		if sect := obj.Section(".gopclntab"); sect != nil {
-			if pclntab, err = sect.Data(); err != nil {
-				return 0, nil, nil, err
-			}
-		}
-		return textStart, symtab, pclntab, nil
-	}
-
-	return 0, nil, nil, fmt.Errorf("unrecognized binary format")
+	return nil, fmt.Errorf("unrecognized binary format")
 }
 
 type file struct {
@@ -337,27 +281,19 @@
 	switch {
 	case strings.HasPrefix(expr, "re:"):
 		// Regular expression. Return list of symbols.
-		expr = expr[3:]
-		re, err := regexp.Compile(expr)
+		re, err := regexp.Compile(expr[3:])
 		if err != nil {
 			return nil, err
 		}
-		strs := make([]string, 0, 100)
-		for _, f := range s.symbols.Funcs {
-			if re.MatchString(f.Sym.Name) {
-				strs = append(strs, f.Sym.Name)
-			}
-		}
-		return strs, nil
+		return s.lookupRE(re)
 
 	case strings.HasPrefix(expr, "sym:"):
 		// Symbol lookup. Return address.
-		expr = expr[4:]
-		sym := s.symbols.LookupFunc(expr)
-		if sym == nil {
-			return nil, fmt.Errorf("symbol %q not found", expr)
+		addr, err := s.lookupSym(expr[4:])
+		if err != nil {
+			return nil, err
 		}
-		return []string{fmt.Sprintf("%#x", sym.Value)}, nil
+		return []string{fmt.Sprintf("%#x", addr)}, nil
 
 	case len(expr) > 0 && '0' <= expr[0] && expr[0] <= '9':
 		// Numerical address. Return symbol.
@@ -365,11 +301,11 @@
 		if err != nil {
 			return nil, err
 		}
-		fun := s.symbols.PCToFunc(addr)
-		if fun == nil {
-			return nil, fmt.Errorf("address %q has no func", expr)
+		funcName, err := s.lookupPC(addr)
+		if err != nil {
+			return nil, err
 		}
-		return []string{fun.Sym.Name}, nil
+		return []string{funcName}, nil
 	}
 
 	return nil, fmt.Errorf("bad expression syntax: %q", expr)
@@ -379,17 +315,16 @@
 // and evaluates it as an address.
 func (s *Server) evalAddress(expr string) (uint64, error) {
 	// Might be a symbol.
-	sym := s.symbols.LookupFunc(expr)
-	if sym != nil {
-		return sym.Value, nil
+	addr, err := s.lookupSym(expr)
+	if err == nil {
+		return addr, nil
 	}
 
 	// Must be a number.
-	addr, err := strconv.ParseUint(expr, 0, 0)
+	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
-
 }