diff --git a/ogle/demo/ogler/ogler_test.go b/ogle/demo/ogler/ogler_test.go
index fc7c511..4c4039f 100644
--- a/ogle/demo/ogler/ogler_test.go
+++ b/ogle/demo/ogler/ogler_test.go
@@ -175,9 +175,9 @@
 		log.Fatalf("Run: %v", err)
 	}
 
-	pcs, err := prog.Breakpoint("re:main.foo")
+	pcs, err := prog.BreakpointAtFunction("main.foo")
 	if err != nil {
-		log.Fatalf("Breakpoint: %v", err)
+		log.Fatalf("BreakpointAtFunction: %v", err)
 	}
 	fmt.Printf("breakpoints set at %x\n", pcs)
 
@@ -267,13 +267,13 @@
 	if err != nil {
 		log.Fatalf("DeleteBreakpoints: %v", err)
 	}
-	pcs1, err := prog.Breakpoint("re:main.f1")
+	pcs1, err := prog.BreakpointAtFunction("main.f1")
 	if err != nil {
-		log.Fatalf("Breakpoint: %v", err)
+		log.Fatalf("BreakpointAtFunction: %v", err)
 	}
-	pcs2, err := prog.Breakpoint("re:main.f2")
+	pcs2, err := prog.BreakpointAtFunction("main.f2")
 	if err != nil {
-		log.Fatalf("Breakpoint: %v", err)
+		log.Fatalf("BreakpointAtFunction: %v", err)
 	}
 	err = prog.DeleteBreakpoints(pcs1)
 	if err != nil {
diff --git a/ogle/program/client/client.go b/ogle/program/client/client.go
index 1eade3a..2464a6d 100644
--- a/ogle/program/client/client.go
+++ b/ogle/program/client/client.go
@@ -180,7 +180,7 @@
 	panic("unimplemented")
 }
 
-func (p *Program) Breakpoint(address string) ([]uint64, error) {
+func (p *Program) Breakpoint(address uint64) ([]uint64, error) {
 	req := proxyrpc.BreakpointRequest{
 		Address: address,
 	}
@@ -189,6 +189,25 @@
 	return resp.PCs, err
 }
 
+func (p *Program) BreakpointAtFunction(name string) ([]uint64, error) {
+	req := proxyrpc.BreakpointAtFunctionRequest{
+		Function: name,
+	}
+	var resp proxyrpc.BreakpointResponse
+	err := p.client.Call("Server.BreakpointAtFunction", &req, &resp)
+	return resp.PCs, err
+}
+
+func (p *Program) BreakpointAtLine(file string, line uint64) ([]uint64, error) {
+	req := proxyrpc.BreakpointAtLineRequest{
+		File: file,
+		Line: line,
+	}
+	var resp proxyrpc.BreakpointResponse
+	err := p.client.Call("Server.BreakpointAtLine", &req, &resp)
+	return resp.PCs, err
+}
+
 func (p *Program) DeleteBreakpoints(pcs []uint64) error {
 	req := proxyrpc.DeleteBreakpointsRequest{PCs: pcs}
 	var resp proxyrpc.DeleteBreakpointsResponse
diff --git a/ogle/program/local/local.go b/ogle/program/local/local.go
index 45868c4..02c7d0c 100644
--- a/ogle/program/local/local.go
+++ b/ogle/program/local/local.go
@@ -72,15 +72,27 @@
 	panic("unimplemented")
 }
 
-func (l *Local) Breakpoint(address string) ([]uint64, error) {
-	req := proxyrpc.BreakpointRequest{
-		Address: address,
-	}
+func (l *Local) Breakpoint(address uint64) ([]uint64, error) {
+	req := proxyrpc.BreakpointRequest{address}
 	var resp proxyrpc.BreakpointResponse
 	err := l.s.Breakpoint(&req, &resp)
 	return resp.PCs, err
 }
 
+func (l *Local) BreakpointAtFunction(name string) ([]uint64, error) {
+	req := proxyrpc.BreakpointAtFunctionRequest{name}
+	var resp proxyrpc.BreakpointResponse
+	err := l.s.BreakpointAtFunction(&req, &resp)
+	return resp.PCs, err
+}
+
+func (l *Local) BreakpointAtLine(file string, line uint64) ([]uint64, error) {
+	req := proxyrpc.BreakpointAtLineRequest{file, line}
+	var resp proxyrpc.BreakpointResponse
+	err := l.s.BreakpointAtLine(&req, &resp)
+	return resp.PCs, err
+}
+
 func (l *Local) DeleteBreakpoints(pcs []uint64) error {
 	req := proxyrpc.DeleteBreakpointsRequest{PCs: pcs}
 	var resp proxyrpc.DeleteBreakpointsResponse
diff --git a/ogle/program/program.go b/ogle/program/program.go
index 77d8b8a..374a019 100644
--- a/ogle/program/program.go
+++ b/ogle/program/program.go
@@ -48,13 +48,13 @@
 	Kill() (Status, error)
 
 	// Breakpoint sets a breakpoint at the specified address.
-	// When the target binary is re-run, breakpoints are
-	// automatically re-established in the new process by
-	// re-evaluating the address.
-	// The address is the same mini-language accepted by Eval,
-	// which permits setting multiple breakpoints using a regular
-	// expression to match a set of symbols.
-	Breakpoint(address string) (PCs []uint64, err error)
+	Breakpoint(address uint64) (PCs []uint64, err error)
+
+	// BreakpointAtFunction sets a breakpoint at the start of the specified function.
+	BreakpointAtFunction(name string) (PCs []uint64, err error)
+
+	// BreakpointAtLine sets a breakpoint at the specified source line.
+	BreakpointAtLine(file string, line uint64) (PCs []uint64, err error)
 
 	// DeleteBreakpoints removes the breakpoints at the specified addresses.
 	// Addresses where no breakpoint is set are ignored.
diff --git a/ogle/program/proxyrpc/proxyrpc.go b/ogle/program/proxyrpc/proxyrpc.go
index 04b2240..91bb49e 100644
--- a/ogle/program/proxyrpc/proxyrpc.go
+++ b/ogle/program/proxyrpc/proxyrpc.go
@@ -78,7 +78,16 @@
 }
 
 type BreakpointRequest struct {
-	Address string
+	Address uint64
+}
+
+type BreakpointAtFunctionRequest struct {
+	Function string
+}
+
+type BreakpointAtLineRequest struct {
+	File string
+	Line uint64
 }
 
 type BreakpointResponse struct {
diff --git a/ogle/program/server/server.go b/ogle/program/server/server.go
index 4afb911..9e5b486 100644
--- a/ogle/program/server/server.go
+++ b/ogle/program/server/server.go
@@ -148,6 +148,10 @@
 	switch req := c.req.(type) {
 	case *proxyrpc.BreakpointRequest:
 		c.errc <- s.handleBreakpoint(req, c.resp.(*proxyrpc.BreakpointResponse))
+	case *proxyrpc.BreakpointAtFunctionRequest:
+		c.errc <- s.handleBreakpointAtFunction(req, c.resp.(*proxyrpc.BreakpointResponse))
+	case *proxyrpc.BreakpointAtLineRequest:
+		c.errc <- s.handleBreakpointAtLine(req, c.resp.(*proxyrpc.BreakpointResponse))
 	case *proxyrpc.DeleteBreakpointsRequest:
 		c.errc <- s.handleDeleteBreakpoints(req, c.resp.(*proxyrpc.DeleteBreakpointsResponse))
 	case *proxyrpc.CloseRequest:
@@ -399,29 +403,49 @@
 }
 
 func (s *Server) handleBreakpoint(req *proxyrpc.BreakpointRequest, resp *proxyrpc.BreakpointResponse) error {
-	addrs, err := s.eval(req.Address)
+	return s.addBreakpoints([]uint64{req.Address}, resp)
+}
+
+func (s *Server) BreakpointAtFunction(req *proxyrpc.BreakpointAtFunctionRequest, resp *proxyrpc.BreakpointResponse) error {
+	return s.call(s.breakpointc, req, resp)
+}
+
+func (s *Server) handleBreakpointAtFunction(req *proxyrpc.BreakpointAtFunctionRequest, resp *proxyrpc.BreakpointResponse) error {
+	pc, err := s.lookupFunction(req.Function)
 	if err != nil {
 		return err
 	}
-	var bp breakpoint
-	for _, addr := range addrs {
-		pc, err := s.evalAddress(addr)
-		if err != nil {
-			return err
-		}
-		if _, alreadySet := s.breakpoints[pc]; alreadySet {
-			return fmt.Errorf("breakpoint already set at %#x (TODO)", pc)
-		}
+	return s.addBreakpoints([]uint64{pc}, resp)
+}
 
-		err = s.ptracePeek(s.stoppedPid, uintptr(pc), bp.origInstr[:s.arch.BreakpointSize])
-		if err != nil {
+func (s *Server) BreakpointAtLine(req *proxyrpc.BreakpointAtLineRequest, resp *proxyrpc.BreakpointResponse) error {
+	return s.call(s.breakpointc, req, resp)
+}
+
+func (s *Server) handleBreakpointAtLine(req *proxyrpc.BreakpointAtLineRequest, resp *proxyrpc.BreakpointResponse) error {
+	return fmt.Errorf("not implemented")
+}
+
+// addBreakpoints adds breakpoints at the addresses in pcs, then stores pcs in the response.
+func (s *Server) addBreakpoints(pcs []uint64, resp *proxyrpc.BreakpointResponse) error {
+	// Get the original code at each address with ptracePeek.
+	bps := make([]breakpoint, 0, len(pcs))
+	for _, pc := range pcs {
+		if _, alreadySet := s.breakpoints[pc]; alreadySet {
+			continue
+		}
+		var bp breakpoint
+		if err := s.ptracePeek(s.stoppedPid, uintptr(pc), bp.origInstr[:s.arch.BreakpointSize]); err != nil {
 			return fmt.Errorf("ptracePeek: %v", err)
 		}
 		bp.pc = pc
-		s.breakpoints[pc] = bp
-		resp.PCs = append(resp.PCs, pc)
+		bps = append(bps, bp)
 	}
-
+	// If all the peeks succeeded, update the list of breakpoints.
+	for _, bp := range bps {
+		s.breakpoints[bp.pc] = bp
+	}
+	resp.PCs = pcs
 	return nil
 }