diff --git a/debug/dwarf/line.go b/debug/dwarf/line.go
new file mode 100644
index 0000000..5a23922
--- /dev/null
+++ b/debug/dwarf/line.go
@@ -0,0 +1,421 @@
+// 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 dwarf
+
+// Mapping from PC to lines.
+// http://www.dwarfstd.org/doc/DWARF4.pdf Section 6.2 page 108
+
+// TODO: Convert the I/O to use the buffer interface defined in buf.go.
+// TODO: Find a way to test this properly.
+
+import (
+	"encoding/binary"
+	"fmt"
+)
+
+// PCToLine returns the file and line number corresponding to the PC value.
+// If a correspondence cannot be found, ok will be false.
+// TODO: Return a function descriptor as well.
+func (d *Data) PCToLine(pc uint64) (file string, line int, err error) {
+	if len(d.line) == 0 {
+		return
+	}
+	var m lineMachine
+	for offset := 0; offset < len(d.line); {
+		var found bool
+		offset, found, err = m.evalCompilationUnit(d.line, offset, pc)
+		if err != nil {
+			return "", 0, err
+		}
+		if found {
+			return m.prologue.file[m.file].name, int(m.line), nil
+		}
+	}
+	return "", 0, fmt.Errorf("no source line defined for PC %#x", pc)
+}
+
+// Standard opcodes. Figure 37, page 178.
+// If an opcode >= lineMachine.prologue.opcodeBase, it is a special
+// opcode rather than the opcode defined in this table.
+const (
+	lineStdCopy             = 0x01
+	lineStdAdvancePC        = 0x02
+	lineStdAdvanceLine      = 0x03
+	lineStdSetFile          = 0x04
+	lineStdSetColumn        = 0x05
+	lineStdNegateStmt       = 0x06
+	lineStdSetBasicBlock    = 0x07
+	lineStdConstAddPC       = 0x08
+	lineStdFixedAdvancePC   = 0x09
+	lineStdSetPrologueEnd   = 0x0a
+	lineStdSetEpilogueBegin = 0x0b
+	lineStdSetISA           = 0x0c
+)
+
+// Extended opcodes. Figure 38, page 179.
+const (
+	lineStartExtendedOpcode = 0x00 // Not defined as a named constant in the spec.
+	lineExtEndSequence      = 0x01
+	lineExtSetAddress       = 0x02
+	lineExtDefineFile       = 0x03
+	lineExtSetDiscriminator = 0x04 // New in version 4.
+	lineExtLoUser           = 0x80
+	lineExtHiUser           = 0xff
+)
+
+// linePrologue holds the information stored in the prologue of the line
+// table for a single compilation unit. Also called the header.
+// Section 6.2.4, page 112.
+type linePrologue struct {
+	unitLength           int
+	version              int
+	headerLength         int
+	minInstructionLength int
+	maxOpsPerInstruction int
+	defaultIsStmt        bool
+	lineBase             int
+	lineRange            int
+	opcodeBase           byte
+	stdOpcodeLengths     []byte
+	include              []string   // entry 0 is empty; means current directory
+	file                 []lineFile // entry 0 is empty.
+}
+
+// lineFile represents a file name stored in the PC/line table, usually the prologue.
+type lineFile struct {
+	name   string
+	index  int // index into include directories
+	time   int // implementation-defined time of last modification
+	length int // length in bytes, 0 if not available.
+}
+
+// lineMachine holds the registers evaluated during executing of the PC/line mapping engine.
+// Section 6.2.2, page 109.
+type lineMachine struct {
+	// The program-counter value corresponding to a machine instruction generated by the compiler.
+	address uint64
+
+	// An unsigned integer representing the index of an operation within a VLIW
+	// instruction. The index of the first operation is 0. For non-VLIW
+	// architectures, this register will always be 0.
+	// The address and op_index registers, taken together, form an operation
+	// pointer that can reference any individual operation with the instruction
+	// stream.
+	opIndex uint64
+
+	// An unsigned integer indicating the identity of the source file corresponding to a machine instruction.
+	file uint64
+
+	// An unsigned integer indicating a source line number. Lines are numbered
+	// beginning at 1. The compiler may emit the value 0 in cases where an
+	// instruction cannot be attributed to any source line.
+	line uint64
+
+	// An unsigned integer indicating a column number within a source line.
+	// Columns are numbered beginning at 1. The value 0 is reserved to indicate
+	// that a statement begins at the “left edge” of the line.
+	column uint64
+
+	// A boolean indicating that the current instruction is a recommended
+	// breakpoint location. A recommended breakpoint location is intended to
+	// “represent” a line, a statement and/or a semantically distinct subpart of a
+	// statement.
+	isStmt bool
+
+	// A boolean indicating that the current instruction is the beginning of a basic
+	// block.
+	basicBlock bool
+
+	// A boolean indicating that the current address is that of the first byte after
+	// the end of a sequence of target machine instructions. end_sequence
+	// terminates a sequence of lines; therefore other information in the same
+	// row is not meaningful.
+	endSequence bool
+
+	// A boolean indicating that the current address is one (of possibly many)
+	// where execution should be suspended for an entry breakpoint of a
+	// function.
+	prologueEnd bool
+
+	// A boolean indicating that the current address is one (of possibly many)
+	// where execution should be suspended for an exit breakpoint of a function.
+	epilogueBegin bool
+
+	// An unsigned integer whose value encodes the applicable instruction set
+	// architecture for the current instruction.
+	// The encoding of instruction sets should be shared by all users of a given
+	// architecture. It is recommended that this encoding be defined by the ABI
+	// authoring committee for each architecture.
+	isa uint64
+
+	// An unsigned integer identifying the block to which the current instruction
+	// belongs. Discriminator values are assigned arbitrarily by the DWARF
+	// producer and serve to distinguish among multiple blocks that may all be
+	// associated with the same source file, line, and column. Where only one
+	// block exists for a given source position, the discriminator value should be
+	// zero.
+	discriminator uint64
+
+	// The prologue for the current compilation unit.
+	// Not an actual register, but stored here for cleanlineness.
+	prologue linePrologue
+}
+
+// parseLinePrologue parses the prologue/header describing the compilation
+// unit in the line table starting at the specified offset.
+func (m *lineMachine) parseLinePrologue(data []byte, offset int) (int, error) {
+	// TODO: Assumes little endian
+	m.prologue = linePrologue{}
+	m.prologue.unitLength = int(binary.LittleEndian.Uint32(data[offset:]))
+	if m.prologue.unitLength > len(data)-4 {
+		return 0, fmt.Errorf("DWARF: bad PC/line header length")
+	}
+	offset += 4
+	m.prologue.version = int(binary.LittleEndian.Uint16(data[offset:]))
+	offset += 2
+	m.prologue.headerLength = int(binary.LittleEndian.Uint32(data[offset:]))
+	offset += 4
+	m.prologue.minInstructionLength = int(data[offset])
+	offset += 1
+	if m.prologue.version >= 4 {
+		m.prologue.maxOpsPerInstruction = int(data[offset])
+		offset += 1
+	} else {
+		m.prologue.maxOpsPerInstruction = 1
+	}
+	m.prologue.defaultIsStmt = data[offset] != 0
+	offset += 1
+	m.prologue.lineBase = int(int8(data[offset]))
+	offset += 1
+	m.prologue.lineRange = int(data[offset])
+	offset += 1
+	m.prologue.opcodeBase = data[offset]
+	offset += 1
+	m.prologue.stdOpcodeLengths = make([]byte, m.prologue.opcodeBase-1)
+	copy(m.prologue.stdOpcodeLengths, data[offset:])
+	offset += int(m.prologue.opcodeBase - 1)
+	m.prologue.include = make([]string, 1) // First entry is empty; file index entries are 1-indexed.
+	// Includes
+	for {
+		if data[offset] == 0 {
+			offset++
+			break
+		}
+		startOfName := offset
+		for data[offset] != 0 {
+			offset++
+		}
+		m.prologue.include = append(m.prologue.include, string(data[startOfName:offset]))
+		offset++ // terminal NUL
+	}
+	// Files
+	m.prologue.file = make([]lineFile, 1, 10) // entries are 1-indexed in line number program.
+	for {
+		if data[offset] == 0 {
+			offset++
+			break
+		}
+		startOfName := offset
+		for data[offset] != 0 {
+			offset++
+		}
+		name := data[startOfName:offset]
+		offset++ // terminal NUL
+		index, w := uleb128(data[offset:])
+		offset += w
+		time, w := uleb128(data[offset:])
+		offset += w
+		length, w := uleb128(data[offset:])
+		offset += w
+		f := lineFile{
+			name:   string(name),
+			index:  int(index),
+			time:   int(time),
+			length: int(length),
+		}
+		m.prologue.file = append(m.prologue.file, f)
+	}
+	return offset, nil
+}
+
+// Special opcodes, page 117.
+func (m *lineMachine) specialOpcode(opcode byte) {
+	adjustedOpcode := int(opcode - m.prologue.opcodeBase)
+	advance := adjustedOpcode / m.prologue.lineRange
+	delta := (int(m.opIndex) + advance) / m.prologue.maxOpsPerInstruction
+	m.address += uint64(m.prologue.minInstructionLength * delta)
+	m.opIndex = (m.opIndex + uint64(advance)) % uint64(m.prologue.maxOpsPerInstruction)
+	lineAdvance := m.prologue.lineBase + (adjustedOpcode % m.prologue.lineRange)
+	m.line += uint64(lineAdvance)
+	m.basicBlock = false
+	m.prologueEnd = false
+	m.epilogueBegin = false
+	m.discriminator = 0
+}
+
+// evalCompilationUnit scans the compilation unit starting at the specified offset to see if it contains the PC.
+// It returns when it finds the PC or at the end of the compilation unit.
+// The return values are the offset where it stops and whether the PC was found; if so,
+// the machine's registers contain the relevant information.
+func (m *lineMachine) evalCompilationUnit(data []byte, startOffset int, pc uint64) (int, bool, error) {
+	offset, err := m.parseLinePrologue(data, startOffset)
+	if err != nil {
+		return offset, false, err
+	}
+	m.reset()
+	for offset < len(data) {
+		op := data[offset]
+		offset++
+		if op >= m.prologue.opcodeBase {
+			m.specialOpcode(op)
+			continue
+		}
+		switch op {
+		case lineStartExtendedOpcode:
+			if len(data) == 0 {
+				return offset, false, fmt.Errorf("DWARF: short extended opcode (1)")
+			}
+			size, wid := uleb128(data[offset:])
+			if uint64(len(data)) < size {
+				return offset, false, fmt.Errorf("DWARF: short extended opcode (2)")
+			}
+			offset += int(wid)
+			op = data[offset]
+			offset++
+			switch op {
+			case lineExtEndSequence:
+				m.endSequence = true
+				m.reset()
+				return offset, false, nil
+			case lineExtSetAddress:
+				var addr uint64
+				// TODO: Assumes little-endian.
+				switch size {
+				case 1 + 4: // TODO: How should we do this?
+					addr = uint64(binary.LittleEndian.Uint32(data[offset:]))
+					offset += 4
+				case 1 + 8:
+					addr = binary.LittleEndian.Uint64(data[offset:])
+					offset += 8
+				}
+				m.address = addr
+				m.opIndex = 0
+			case lineExtDefineFile:
+				return offset, false, fmt.Errorf("DWARF: unimplemented define_file op")
+			case lineExtSetDiscriminator:
+				discriminator, wid := uleb128(data[offset:])
+				m.line = discriminator
+				offset += wid
+			default:
+				return offset, false, fmt.Errorf("DWARF: unknown extended opcode %#x", op)
+			}
+		case lineStdCopy:
+			m.discriminator = 0
+			m.basicBlock = false
+			m.prologueEnd = false
+			m.epilogueBegin = false
+			if m.address >= pc {
+				// TODO: if m.address > pc, is this one step too far?
+				return offset, true, nil
+			}
+		case lineStdAdvancePC:
+			advance, wid := uleb128(data[offset:])
+			delta := (int(m.opIndex) + int(advance)) / m.prologue.maxOpsPerInstruction
+			m.address += uint64(m.prologue.minInstructionLength * delta)
+			m.opIndex = (m.opIndex + uint64(advance)) % uint64(m.prologue.maxOpsPerInstruction)
+			offset += wid
+			m.basicBlock = false
+			m.prologueEnd = false
+			m.epilogueBegin = false
+			m.discriminator = 0
+		case lineStdAdvanceLine:
+			advance, wid := sleb128(data[offset:])
+			m.line = uint64(int64(m.line) + advance)
+			offset += wid
+		case lineStdSetFile:
+			index, wid := uleb128(data[offset:])
+			m.file = index
+			offset += wid
+		case lineStdSetColumn:
+			column, wid := uleb128(data[offset:])
+			m.column = column
+			offset += wid
+		case lineStdNegateStmt:
+			m.isStmt = !m.isStmt
+		case lineStdSetBasicBlock:
+			m.basicBlock = true
+		case lineStdFixedAdvancePC:
+			delta := binary.LittleEndian.Uint16(data[offset:])
+			m.address += uint64(delta)
+			m.opIndex = 0
+			offset += 2
+		case lineStdSetPrologueEnd:
+			m.prologueEnd = true
+		case lineStdSetEpilogueBegin:
+			m.epilogueBegin = true
+		case lineStdSetISA:
+			isa, wid := uleb128(data[offset:])
+			m.isa = isa
+			offset += wid
+		case lineStdConstAddPC:
+			// TODO: Is this right? Seems crazy - why not just use 255 as a special opcode?
+			m.specialOpcode(255)
+		default:
+			panic("not reached")
+		}
+	}
+	panic("not reached")
+}
+
+// reset sets the machine's registers to the initial state. Page 111.
+func (m *lineMachine) reset() {
+	m.address = 0
+	m.opIndex = 0
+	m.file = 1
+	m.line = 1
+	m.column = 0
+	m.isStmt = m.prologue.defaultIsStmt
+	m.basicBlock = false
+	m.endSequence = false
+	m.prologueEnd = false
+	m.epilogueBegin = false
+	m.isa = 0
+	m.discriminator = 0
+}
+
+// uleb128 decodes a varint-encoded unsigned integer.
+// TODO: use the buffer interface.
+func uleb128(v []uint8) (u uint64, length int) {
+	var shift uint
+	var x byte
+	for length, x = range v {
+		u |= (uint64(x) & 0x7F) << shift
+		shift += 7
+		if x&0x80 == 0 {
+			break
+		}
+	}
+	return u, length + 1
+}
+
+// sleb128 decodes a varint-encoded signed integer.
+// TODO: use the buffer interface.
+func sleb128(v []uint8) (s int64, length int) {
+	var shift uint
+	var sign int64 = -1
+	var x byte
+	for length, x = range v {
+		s |= (int64(x) & 0x7F) << shift
+		shift += 7
+		sign <<= 7
+		if x&0x80 == 0 {
+			if x&0x40 != 0 {
+				s |= sign
+			}
+			break
+		}
+	}
+	return s, length + 1
+}
diff --git a/debug/elf/file.go b/debug/elf/file.go
index 134b28b..65c6b89 100644
--- a/debug/elf/file.go
+++ b/debug/elf/file.go
@@ -575,7 +575,8 @@
 	// There are many other DWARF sections, but these
 	// are the required ones, and the debug/dwarf package
 	// does not use the others, so don't bother loading them.
-	var names = [...]string{"abbrev", "info", "str"}
+	// r: added line.
+	var names = [...]string{"abbrev", "info", "line", "str"}
 	var dat [len(names)][]byte
 	for i, name := range names {
 		name = ".debug_" + name
@@ -604,8 +605,8 @@
 		}
 	}
 
-	abbrev, info, str := dat[0], dat[1], dat[2]
-	d, err := dwarf.New(abbrev, nil, nil, info, nil, nil, nil, str)
+	abbrev, info, line, str := dat[0], dat[1], dat[2], dat[3]
+	d, err := dwarf.New(abbrev, nil, nil, info, line, nil, nil, str)
 	if err != nil {
 		return nil, err
 	}
diff --git a/program/server/server.go b/program/server/server.go
index 57824a1..bf7150b 100644
--- a/program/server/server.go
+++ b/program/server/server.go
@@ -144,7 +144,7 @@
 }
 
 // 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.
+// TODO: Delete this once we know how to get PC/SPoff data out of DWARF.
 func parseElf(f *elf.File) (*gosym.Table, error) {
 	symdat, err := f.Section(".gosymtab").Data() // TODO unused.
 	if err != nil {
@@ -426,9 +426,9 @@
 		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)
+		file, line, err := s.lookupSource(addr)
+		if err != nil {
+			return nil, err
 		}
 		return []string{fmt.Sprintf("%s:%d", file, line)}, nil
 
@@ -448,12 +448,13 @@
 	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 {
+func (s *Server) lookupSource(pc uint64) (file string, line int, err error) {
+	if s.dwarfData == nil {
 		return
 	}
-	file, line, fn := s.table.PCToLine(pc)
-	return file, line, fn != nil
+	// TODO: The gosym equivalent also returns the relevant Func. Do that when
+	// DWARF has the same facility.
+	return s.dwarfData.PCToLine(pc)
 }
 
 // evalAddress takes a simple expression, either a symbol or hex value,