cmd/prof, libmach: delete

We have never released cmd/prof and don't plan to.
Now that nm, addr2line, and objdump have been rewritten in Go,
cmd/prof is the only thing keeping us from deleting libmach.

Delete cmd/prof, and then since nothing is using libmach, delete libmach.

13,000 lines of C deleted.

LGTM=minux.ma
R=golang-codereviews, minux.ma
CC=golang-codereviews, iant, r
https://codereview.appspot.com/87020044

1 files changed, 0 insertions, 1008 deletions

diff --git a/src/libmach/linux.c b/src/libmach/linux.c
deleted file mode 100644
index 89f3b2070..000000000
--- a/src/libmach/linux.c
+++ /dev/null
@@ -1,1008 +0,0 @@
-// Derived from Plan 9 from User Space src/libmach/Linux.c
-// http://code.swtch.com/plan9port/src/tip/src/libmach/Linux.c
-//
-//	Copyright © 1994-1999 Lucent Technologies Inc.
-//	Power PC support Copyright © 1995-2004 C H Forsyth (forsyth@terzarima.net).
-//	Portions Copyright © 1997-1999 Vita Nuova Limited.
-//	Portions Copyright © 2000-2007 Vita Nuova Holdings Limited (www.vitanuova.com).
-//	Revisions Copyright © 2000-2004 Lucent Technologies Inc. and others.
-//	Portions Copyright © 2001-2007 Russ Cox.
-//	Portions Copyright © 2009 The Go Authors.  All rights reserved.
-//
-// Permission is hereby granted, free of charge, to any person obtaining a copy
-// of this software and associated documentation files (the "Software"), to deal
-// in the Software without restriction, including without limitation the rights
-// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-// copies of the Software, and to permit persons to whom the Software is
-// furnished to do so, subject to the following conditions:
-//
-// The above copyright notice and this permission notice shall be included in
-// all copies or substantial portions of the Software.
-//
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
-// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-// THE SOFTWARE.
-
-#include <u.h>
-#include <sys/syscall.h>	/* for tkill */
-#include <unistd.h>
-#include <dirent.h>
-#include <sys/ptrace.h>
-#include <sys/signal.h>
-#include <sys/wait.h>
-#include <errno.h>
-#include <libc.h>
-#include <bio.h>
-#include <mach.h>
-#include <ureg_x86.h>
-#include <ureg_amd64.h>
-#undef waitpid
-
-// The old glibc used with crosstool compilers on thresher
-// doesn't know these numbers, but the Linux kernel
-// had them as far back as 2.6.0.
-#ifndef WSTOPPED
-#define WSTOPPED 2
-#define WCONTINUED 8
-#define WIFCONTINUED(x) ((x) == 0xffff)
-#endif
-#ifndef PTRACE_SETOPTIONS
-#define PTRACE_SETOPTIONS 0x4200
-#define PTRACE_GETEVENTMSG 0x4201
-#define PTRACE_O_TRACEFORK 0x2
-#define PTRACE_O_TRACEVFORK 0x4
-#define PTRACE_O_TRACECLONE 0x8
-#define PTRACE_O_TRACEEXEC 0x10
-#define PTRACE_O_TRACEVFORKDONE 0x20
-#define PTRACE_O_TRACEEXIT 0x40
-#define PTRACE_EVENT_FORK 0x1
-#define PTRACE_EVENT_VFORK 0x2
-#define PTRACE_EVENT_CLONE 0x3
-#define PTRACE_EVENT_EXEC 0x4
-#define PTRACE_EVENT_VFORK_DONE 0x5
-#define PTRACE_EVENT_EXIT 0x6
-#endif
-
-static Maprw ptracesegrw;
-static Maprw ptraceregrw;
-
-// /usr/include/asm-x86_64/user.h
-struct user_regs_struct {
-	unsigned long r15,r14,r13,r12,rbp,rbx,r11,r10;
-	unsigned long r9,r8,rax,rcx,rdx,rsi,rdi,orig_rax;
-	unsigned long rip,cs,eflags;
-	unsigned long rsp,ss;
-  	unsigned long fs_base, gs_base;
-	unsigned long ds,es,fs,gs;
-};
-
-// Linux gets very upset if a debugger forgets the reported state
-// of a debugged process, so we keep everything we know about
-// a debugged process in the LinuxThread structure.
-//
-// We can poll for state changes by calling waitpid and interpreting
-// the integer status code that comes back.  Wait1 does this.
-//
-// If the process is already running, it is an error to PTRACE_CONT it.
-//
-// If the process is already stopped, it is an error to stop it again.
-//
-// If the process is stopped because of a signal, the debugger must
-// relay the signal to the PTRACE_CONT call, or else the signal is
-// dropped.
-//
-// If the process exits, the debugger should detach so that the real
-// parent can reap the zombie.
-//
-// On first attach, the debugger should set a handful of flags in order
-// to catch future events like fork, clone, exec, etc.
-
-// One for every attached thread.
-typedef struct LinuxThread LinuxThread;
-struct LinuxThread
-{
-	int pid;
-	int tid;
-	int state;
-	int signal;
-	int child;
-	int exitcode;
-};
-
-static int trace = 0;
-
-static LinuxThread **thr;
-static int nthr;
-static int mthr;
-
-static int realpid(int pid);
-
-enum
-{
-	Unknown,
-	Detached,
-	Attached,
-	AttachStop,
-	Stopped,
-	Running,
-	Forking,
-	Vforking,
-	VforkDone,
-	Cloning,
-	Execing,
-	Exiting,
-	Exited,
-	Killed,
-
-	NSTATE,
-};
-
-static char* statestr[NSTATE] = {
-	"Unknown",
-	"Detached",
-	"Attached",
-	"AttachStop",
-	"Stopped",
-	"Running",
-	"Forking",
-	"Vforking",
-	"VforkDone",
-	"Cloning",
-	"Execing",
-	"Exiting",
-	"Exited",
-	"Killed"
-};
-
-static LinuxThread*
-attachthread(int pid, int tid, int *new, int newstate)
-{
-	int i, n, status;
-	LinuxThread **p, *t;
-	uintptr flags;
-
-	if(new)
-		*new = 0;
-
-	for(i=0; i<nthr; i++)
-		if((pid == 0 || thr[i]->pid == pid) && thr[i]->tid == tid) {
-			t = thr[i];
-			goto fixup;
-		}
-
-	if(!new)
-		return nil;
-
-	if(nthr >= mthr) {
-		n = mthr;
-		if(n == 0)
-			n = 64;
-		else
-			n *= 2;
-		p = realloc(thr, n*sizeof thr[0]);
-		if(p == nil)
-			return nil;
-		thr = p;
-		mthr = n;
-	}
-
-	t = malloc(sizeof *t);
-	if(t == nil)
-		return nil;
-	memset(t, 0, sizeof *t);
-
-	thr[nthr++] = t;
-	if(pid == 0 && nthr > 0)
-		pid = thr[0]->pid;
-	t->pid = pid;
-	t->tid = tid;
-	t->state = newstate;
-	if(trace)
-		fprint(2, "new thread %d %d\n", t->pid, t->tid);
-	if(new)
-		*new = 1;
-
-fixup:
-	if(t->state == Detached) {
-		if(ptrace(PTRACE_ATTACH, tid, 0, 0) < 0) {
-			fprint(2, "ptrace ATTACH %d: %r\n", tid);
-			return nil;
-		}
-		t->state = Attached;
-	}
-
-	if(t->state == Attached) {
-		// wait for stop, so we can set options
-		if(waitpid(tid, &status, __WALL|WUNTRACED|WSTOPPED) < 0)
-			return nil;
-		if(!WIFSTOPPED(status)) {
-			fprint(2, "waitpid %d: status=%#x not stopped\n", tid);
-			return nil;
-		}
-		t->state = AttachStop;
-	}
-
-	if(t->state == AttachStop) {
-		// set options so we'll find out about new threads
-		flags = PTRACE_O_TRACEFORK |
-			PTRACE_O_TRACEVFORK |
-			PTRACE_O_TRACECLONE |
-			PTRACE_O_TRACEEXEC |
-			PTRACE_O_TRACEVFORKDONE;
-		if(ptrace(PTRACE_SETOPTIONS, tid, 0, (void*)flags) < 0)	{
-			fprint(2, "ptrace PTRACE_SETOPTIONS %d: %r\n", tid);
-			return nil;
-		}
-		t->state = Stopped;
-	}
-
-	return t;
-}
-
-static LinuxThread*
-findthread(int tid)
-{
-	return attachthread(0, tid, nil, 0);
-}
-
-int
-procthreadpids(int pid, int *p, int np)
-{
-	int i, n;
-	LinuxThread *t;
-
-	n = 0;
-	for(i=0; i<nthr; i++) {
-		t = thr[i];
-		if(t->pid == pid) {
-			switch(t->state) {
-			case Exited:
-			case Detached:
-			case Killed:
-				break;
-
-			default:
-				if(n < np)
-					p[n] = t->tid;
-				n++;
-				break;
-			}
-		}
-	}
-	return n;
-}
-
-// Execute a single wait and update the corresponding thread.
-static int
-wait1(int nohang)
-{
-	int tid, new, status, event;
-	ulong data;
-	LinuxThread *t;
-	enum
-	{
-		NormalStop = 0x137f
-	};
-
-	if(nohang != 0)
-		nohang = WNOHANG;
-
-	status = 0;
-	tid = waitpid(-1, &status, __WALL|WUNTRACED|WSTOPPED|WCONTINUED|nohang);
-
-	if(tid < 0)
-		return -1;
-	if(tid == 0)
-		return 0;
-
-	if(trace > 0 && status != NormalStop)
-		fprint(2, "TID %d: %#x\n", tid, status);
-
-	t = findthread(tid);
-	if(t == nil) {
-		// Sometimes the kernel tells us about new threads
-		// before we see the parent clone.
-		t = attachthread(0, tid, &new, Stopped);
-		if(t == nil) {
-			fprint(2, "failed to attach to new thread %d\n", tid);
-			return -1;
-		}
-	}
-
-	if(WIFSTOPPED(status)) {
-		t->state = Stopped;
-		t->signal = WSTOPSIG(status);
-		if(trace)
-			fprint(2, "tid %d: stopped %#x%s\n", tid, status,
-				status != NormalStop ? " ***" : "");
-		if(t->signal == SIGTRAP && (event = status>>16) != 0) {	// ptrace event
-			switch(event) {
-			case PTRACE_EVENT_FORK:
-				t->state = Forking;
-				goto child;
-
-			case PTRACE_EVENT_VFORK:
-				t->state = Vforking;
-				goto child;
-
-			case PTRACE_EVENT_CLONE:
-				t->state = Cloning;
-				goto child;
-
-			child:
-				if(ptrace(PTRACE_GETEVENTMSG, t->tid, 0, &data) < 0) {
-					fprint(2, "ptrace GETEVENTMSG tid %d: %r\n", tid);
-					break;
-				}
-				t->child = data;
-				attachthread(t->pid, t->child, &new, Running);
-				break;
-
-			case PTRACE_EVENT_EXEC:
-				t->state = Execing;
-				break;
-
-			case PTRACE_EVENT_VFORK_DONE:
-				t->state = VforkDone;
-				break;
-
-			case PTRACE_EVENT_EXIT:
-				// We won't see this unless we set PTRACE_O_TRACEEXIT.
-				// The debuggers assume that a read or write on a Map
-				// will fail for a thread that has exited.  This event
-				// breaks that assumption.  It's not a big deal: we
-				// only lose the ability to see the register state at
-				// the time of exit.
-				if(trace)
-					fprint(2, "tid %d: exiting %#x\n", tid, status);
-				t->state = Exiting;
-				if(ptrace(PTRACE_GETEVENTMSG, t->tid, 0, &data) < 0) {
-					fprint(2, "ptrace GETEVENTMSG tid %d: %r\n", tid);
-					break;
-				}
-				t->exitcode = data;
-				break;
-			}
-		}
-	}
-	if(WIFCONTINUED(status)) {
-		if(trace)
-			fprint(2, "tid %d: continued %#x\n", tid, status);
-		t->state = Running;
-	}
-	if(WIFEXITED(status)) {
-		if(trace)
-			fprint(2, "tid %d: exited %#x\n", tid, status);
-		t->state = Exited;
-		t->exitcode = WEXITSTATUS(status);
-		t->signal = -1;
-		ptrace(PTRACE_DETACH, t->tid, 0, 0);
-		if(trace)
-			fprint(2, "tid %d: detach exited\n", tid);
-	}
-	if(WIFSIGNALED(status)) {
-		if(trace)
-			fprint(2, "tid %d: signaled %#x\n", tid, status);
-		t->state = Exited;
-		t->signal = WTERMSIG(status);
-		t->exitcode = -1;
-		ptrace(PTRACE_DETACH, t->tid, 0, 0);
-		if(trace)
-			fprint(2, "tid %d: detach signaled\n", tid);
-	}
-	return 1;
-}
-
-static int
-waitstop(LinuxThread *t)
-{
-	while(t->state == Running)
-		if(wait1(0) < 0)
-			return -1;
-	return 0;
-}
-
-// Attach to and stop all threads in process pid.
-// Must stop everyone in order to make sure we set
-// the "tell me about new threads" option in every
-// task.
-int
-attachallthreads(int pid)
-{
-	int tid, foundnew, new;
-	char buf[100];
-	DIR *d;
-	struct dirent *de;
-	LinuxThread *t;
-
-	if(pid == 0) {
-		fprint(2, "attachallthreads(0)\n");
-		return -1;
-	}
-
-	pid = realpid(pid);
-
-	snprint(buf, sizeof buf, "/proc/%d/task", pid);
-	if((d = opendir(buf)) == nil) {
-		fprint(2, "opendir %s: %r\n", buf);
-		return -1;
-	}
-
-	// Loop in case new threads are being created right now.
-	// We stop every thread as we find it, so eventually
-	// this has to stop (or the system runs out of procs).
-	do {
-		foundnew = 0;
-		while((de = readdir(d)) != nil) {
-			tid = atoi(de->d_name);
-			if(tid == 0)
-				continue;
-			t = attachthread(pid, tid, &new, Detached);
-			foundnew |= new;
-			if(t)
-				waitstop(t);
-		}
-		rewinddir(d);
-	} while(foundnew);
-	closedir(d);
-
-	return 0;
-}
-
-Map*
-attachproc(int pid, Fhdr *fp)
-{
-	Map *map;
-
-	if(pid == 0) {
-		fprint(2, "attachproc(0)\n");
-		return nil;
-	}
-
-	if(findthread(pid) == nil && attachallthreads(pid) < 0)
-		return nil;
-
-	map = newmap(0, 4);
-	if (!map)
-		return 0;
-	map->pid = pid;
-	if(mach->regsize)
-		setmap(map, -1, 0, mach->regsize, 0, "regs", ptraceregrw);
-//	if(mach->fpregsize)
-//		setmap(map, -1, mach->regsize, mach->regsize+mach->fpregsize, 0, "fpregs", ptraceregrw);
-	setmap(map, -1, fp->txtaddr, fp->txtaddr+fp->txtsz, fp->txtaddr, "*text", ptracesegrw);
-	setmap(map, -1, fp->dataddr, mach->utop, fp->dataddr, "*data", ptracesegrw);
-	return map;
-}
-
-void
-detachproc(Map *m)
-{
-	LinuxThread *t;
-
-	t = findthread(m->pid);
-	if(t != nil) {
-		ptrace(PTRACE_DETACH, t->tid, 0, 0);
-		t->state = Detached;
-		if(trace)
-			fprint(2, "tid %d: detachproc\n", t->tid);
-		// TODO(rsc): Reclaim thread structs somehow?
-	}
-	free(m);
-}
-
-/* /proc/pid/stat contains
-	pid
-	command in parens
-	0. state
-	1. ppid
-	2. pgrp
-	3. session
-	4. tty_nr
-	5. tpgid
-	6. flags (math=4, traced=10)
-	7. minflt
-	8. cminflt
-	9. majflt
-	10. cmajflt
-	11. utime
-	12. stime
-	13. cutime
-	14. cstime
-	15. priority
-	16. nice
-	17. 0
-	18. itrealvalue
-	19. starttime
-	20. vsize
-	21. rss
-	22. rlim
-	23. startcode
-	24. endcode
-	25. startstack
-	26. kstkesp
-	27. kstkeip
-	28. pending signal bitmap
-	29. blocked signal bitmap
-	30. ignored signal bitmap
-	31. caught signal bitmap
-	32. wchan
-	33. nswap
-	34. cnswap
-	35. exit_signal
-	36. processor
-*/
-
-static int
-readstat(int pid, char *buf, int nbuf, char **f, int nf)
-{
-	int fd, n;
-	char *p;
-
-	snprint(buf, nbuf, "/proc/%d/stat", pid);
-	if((fd = open(buf, OREAD)) < 0){
-		fprint(2, "open %s: %r\n", buf);
-		return -1;
-	}
-	n = read(fd, buf, nbuf-1);
-	close(fd);
-	if(n <= 0){
-		fprint(2, "read %s: %r\n", buf);
-		return -1;
-	}
-	buf[n] = 0;
-
-	/* command name is in parens, no parens afterward */
-	p = strrchr(buf, ')');
-	if(p == nil || *++p != ' '){
-		fprint(2, "bad format in /proc/%d/stat\n", pid);
-		return -1;
-	}
-	++p;
-
-	nf = tokenize(p, f, nf);
-	if(0) print("code 0x%lux-0x%lux stack 0x%lux kstk 0x%lux keip 0x%lux pending 0x%lux\n",
-		strtoul(f[23], 0, 0), strtoul(f[24], 0, 0), strtoul(f[25], 0, 0),
-		strtoul(f[26], 0, 0), strtoul(f[27], 0, 0), strtoul(f[28], 0, 0));
-
-	return nf;
-}
-
-static char*
-readstatus(int pid, char *buf, int nbuf, char *key)
-{
-	int fd, n;
-	char *p;
-
-	snprint(buf, nbuf, "/proc/%d/status", pid);
-	if((fd = open(buf, OREAD)) < 0){
-		fprint(2, "open %s: %r\n", buf);
-		return nil;
-	}
-	n = read(fd, buf, nbuf-1);
-	close(fd);
-	if(n <= 0){
-		fprint(2, "read %s: %r\n", buf);
-		return nil;
-	}
-	buf[n] = 0;
-	p = strstr(buf, key);
-	if(p)
-		return p+strlen(key);
-	return nil;
-}
-
-int
-procnotes(int pid, char ***pnotes)
-{
-	char buf[1024], *f[40];
-	int i, n, nf;
-	char *s, **notes;
-	ulong sigs;
-	extern char *_p9sigstr(int, char*);
-
-	*pnotes = nil;
-	nf = readstat(pid, buf, sizeof buf, f, nelem(f));
-	if(nf <= 28)
-		return -1;
-
-	sigs = strtoul(f[28], 0, 0) & ~(1<<SIGCONT);
-	if(sigs == 0){
-		*pnotes = nil;
-		return 0;
-	}
-
-	notes = malloc(32*sizeof(char*));
-	if(notes == nil)
-		return -1;
-	memset(notes, 0, 32*sizeof(char*));
-	n = 0;
-	for(i=0; i<32; i++){
-		if((sigs&(1<<i)) == 0)
-			continue;
-		if((s = _p9sigstr(i, nil)) == nil)
-			continue;
-		notes[n++] = s;
-	}
-	*pnotes = notes;
-	return n;
-}
-
-static int
-realpid(int pid)
-{
-	char buf[1024], *p;
-
-	p = readstatus(pid, buf, sizeof buf, "\nTgid:");
-	if(p == nil)
-		return pid;
-	return atoi(p);
-}
-
-int
-ctlproc(int pid, char *msg)
-{
-	int new;
-	LinuxThread *t;
-	uintptr data;
-
-	while(wait1(1) > 0)
-		;
-
-	if(strcmp(msg, "attached") == 0){
-		t = attachthread(pid, pid, &new, Attached);
-		if(t == nil)
-			return -1;
-		return 0;
-	}
-
-	if(strcmp(msg, "hang") == 0){
-		if(pid == getpid())
-			return ptrace(PTRACE_TRACEME, 0, 0, 0);
-		werrstr("can only hang self");
-		return -1;
-	}
-
-	t = findthread(pid);
-	if(t == nil) {
-		werrstr("not attached to pid %d", pid);
-		return -1;
-	}
-	if(t->state == Exited) {
-		werrstr("pid %d has exited", pid);
-		return -1;
-	}
-	if(t->state == Killed) {
-		werrstr("pid %d has been killed", pid);
-		return -1;
-	}
-
-	if(strcmp(msg, "kill") == 0) {
-		if(ptrace(PTRACE_KILL, pid, 0, 0) < 0)
-			return -1;
-		t->state = Killed;
-		return 0;
-	}
-	if(strcmp(msg, "startstop") == 0){
-		if(ctlproc(pid, "start") < 0)
-			return -1;
-		return waitstop(t);
-	}
-	if(strcmp(msg, "sysstop") == 0){
-		if(ptrace(PTRACE_SYSCALL, pid, 0, 0) < 0)
-			return -1;
-		t->state = Running;
-		return waitstop(t);
-	}
-	if(strcmp(msg, "stop") == 0){
-		if(trace > 1)
-			fprint(2, "tid %d: tkill stop\n", pid);
-		if(t->state == Stopped)
-			return 0;
-		if(syscall(__NR_tkill, pid, SIGSTOP) < 0)
-			return -1;
-		return waitstop(t);
-	}
-	if(strcmp(msg, "step") == 0){
-		if(t->state == Running) {
-			werrstr("cannot single-step unstopped %d", pid);
-			return -1;
-		}
-		if(ptrace(PTRACE_SINGLESTEP, pid, 0, 0) < 0)
-			return -1;
-		return waitstop(t);
-	}
-	if(strcmp(msg, "start") == 0) {
-		if(t->state == Running)
-			return 0;
-		data = 0;
-		if(t->state == Stopped && t->signal != SIGSTOP && t->signal != SIGTRAP)
-			data = t->signal;
-		if(trace && data)
-			fprint(2, "tid %d: continue %lud\n", pid, (ulong)data);
-		if(ptrace(PTRACE_CONT, pid, 0, (void*)data) < 0)
-			return -1;
-		t->state = Running;
-		return 0;
-	}
-	if(strcmp(msg, "waitstop") == 0) {
-		return waitstop(t);
-	}
-	werrstr("unknown control message '%s'", msg);
-	return -1;
-}
-
-char*
-proctextfile(int pid)
-{
-	static char buf[1024], pbuf[128];
-
-	snprint(pbuf, sizeof pbuf, "/proc/%d/exe", pid);
-	if(readlink(pbuf, buf, sizeof buf) >= 0)
-		return strdup(buf);
-	if(access(pbuf, AEXIST) >= 0)
-		return strdup(pbuf);
-	return nil;
-}
-
-
-static int
-ptracerw(int type, int xtype, int isr, int pid, uvlong addr, void *v, uint n)
-{
-	int i;
-	uintptr u, a;
-	uchar buf[sizeof(uintptr)];
-
-	for(i=0; i<n; i+=sizeof(uintptr)){
-		// Tread carefully here.  On recent versions of glibc,
-		// ptrace is a variadic function which means the third
-		// argument will be pushed onto the stack as a uvlong.
-		// This is fine on amd64 but will not work for 386.
-		// We must convert addr to a uintptr.
-		a = addr+i;
-		if(isr){
-			errno = 0;
-			u = ptrace(type, pid, a, 0);
-			if(errno)
-				goto ptraceerr;
-			if(n-i >= sizeof(uintptr))
-				memmove((char*)v+i, &u, sizeof(uintptr));
-			else{
-				memmove(buf, &u, sizeof u);
-				memmove((char*)v+i, buf, n-i);
-			}
-		}else{
-			if(n-i >= sizeof(uintptr))
-				u = *(uintptr*)((char*)v+i);
-			else{
-				errno = 0;
-				u = ptrace(xtype, pid, a, 0);
-				if(errno)
-					return -1;
-				memmove(buf, &u, sizeof u);
-				memmove(buf, (char*)v+i, n-i);
-				memmove(&u, buf, sizeof u);
-			}
-			if(ptrace(type, pid, a, u) < 0)
-				goto ptraceerr;
-		}
-	}
-	return 0;
-
-ptraceerr:
-	werrstr("ptrace %s addr=%#llux pid=%d: %r", isr ? "read" : "write", addr, pid);
-	return -1;
-}
-
-static int
-ptracesegrw(Map *map, Seg *seg, uvlong addr, void *v, uint n, int isr)
-{
-	USED(seg);
-
-	return ptracerw(isr ? PTRACE_PEEKDATA : PTRACE_POKEDATA, PTRACE_PEEKDATA,
-		isr, map->pid, addr, v, n);
-}
-
-// If the debugger is compiled as an x86-64 program,
-// then all the ptrace register read/writes are done on
-// a 64-bit register set.  If the target program
-// is a 32-bit program, the debugger is expected to
-// read the bottom half of the relevant registers
-// out of the 64-bit set.
-
-// Linux 32-bit is
-//	BX CX DX SI DI BP AX DS ES FS GS OrigAX IP CS EFLAGS SP SS
-
-// Linux 64-bit is
-//	R15 R14 R13 R12 BP BX R11 R10 R9 R8 AX CX DX SI DI OrigAX IP CS EFLAGS SP SS FSBase GSBase DS ES FS GS
-
-// Go 32-bit is
-//	DI SI BP NSP BX DX CX AX GS FS ES DS TRAP ECODE PC CS EFLAGS SP SS
-
-uint go32tolinux32tab[] = {
-	4, 3, 5, 15, 0, 2, 1, 6, 10, 9, 8, 7, -1, -1, 12, 13, 14, 15, 16
-};
-static int
-go32tolinux32(uvlong addr)
-{
-	int r;
-
-	if(addr%4 || addr/4 >= nelem(go32tolinux32tab))
-		return -1;
-	r = go32tolinux32tab[addr/4];
-	if(r < 0)
-		return -1;
-	return r*4;
-}
-
-uint go32tolinux64tab[] = {
-	14, 13, 4, 19, 5, 12, 11, 10, 26, 25, 24, 23, -1, -1, 16, 17, 18, 19, 20
-};
-static int
-go32tolinux64(uvlong addr)
-{
-	int r;
-
-	if(addr%4 || addr/4 >= nelem(go32tolinux64tab))
-		return -1;
-	r = go32tolinux64tab[addr/4];
-	if(r < 0)
-		return -1;
-	return r*8;
-}
-
-extern Mach mi386;
-extern Mach mamd64;
-
-static int
-go2linux(uvlong addr)
-{
-	if(sizeof(void*) == 4) {
-		if(mach == &mi386)
-			return go32tolinux32(addr);
-		werrstr("unsupported architecture");
-		return -1;
-	}
-
-	if(mach == &mi386)
-		return go32tolinux64(addr);
-	if(mach != &mamd64) {
-		werrstr("unsupported architecture");
-		return -1;
-	}
-
-	switch(addr){
-	case offsetof(UregAmd64, ax):
-		return offsetof(struct user_regs_struct, rax);
-	case offsetof(UregAmd64, bx):
-		return offsetof(struct user_regs_struct, rbx);
-	case offsetof(UregAmd64, cx):
-		return offsetof(struct user_regs_struct, rcx);
-	case offsetof(UregAmd64, dx):
-		return offsetof(struct user_regs_struct, rdx);
-	case offsetof(UregAmd64, si):
-		return offsetof(struct user_regs_struct, rsi);
-	case offsetof(UregAmd64, di):
-		return offsetof(struct user_regs_struct, rdi);
-	case offsetof(UregAmd64, bp):
-		return offsetof(struct user_regs_struct, rbp);
-	case offsetof(UregAmd64, r8):
-		return offsetof(struct user_regs_struct, r8);
-	case offsetof(UregAmd64, r9):
-		return offsetof(struct user_regs_struct, r9);
-	case offsetof(UregAmd64, r10):
-		return offsetof(struct user_regs_struct, r10);
-	case offsetof(UregAmd64, r11):
-		return offsetof(struct user_regs_struct, r11);
-	case offsetof(UregAmd64, r12):
-		return offsetof(struct user_regs_struct, r12);
-	case offsetof(UregAmd64, r13):
-		return offsetof(struct user_regs_struct, r13);
-	case offsetof(UregAmd64, r14):
-		return offsetof(struct user_regs_struct, r14);
-	case offsetof(UregAmd64, r15):
-		return offsetof(struct user_regs_struct, r15);
-	case offsetof(UregAmd64, ds):
-		return offsetof(struct user_regs_struct, ds);
-	case offsetof(UregAmd64, es):
-		return offsetof(struct user_regs_struct, es);
-	case offsetof(UregAmd64, fs):
-		return offsetof(struct user_regs_struct, fs);
-	case offsetof(UregAmd64, gs):
-		return offsetof(struct user_regs_struct, gs);
-	case offsetof(UregAmd64, ip):
-		return offsetof(struct user_regs_struct, rip);
-	case offsetof(UregAmd64, cs):
-		return offsetof(struct user_regs_struct, cs);
-	case offsetof(UregAmd64, flags):
-		return offsetof(struct user_regs_struct, eflags);
-	case offsetof(UregAmd64, sp):
-		return offsetof(struct user_regs_struct, rsp);
-	case offsetof(UregAmd64, ss):
-		return offsetof(struct user_regs_struct, ss);
-	}
-	return -1;
-}
-
-static int
-ptraceregrw(Map *map, Seg *seg, uvlong addr, void *v, uint n, int isr)
-{
-	int laddr;
-	uvlong u;
-	
-	USED(seg);
-
-	if((laddr = go2linux(addr)) < 0){
-		if(isr){
-			memset(v, 0, n);
-			return 0;
-		}
-		werrstr("register %llud not available", addr);
-		return -1;
-	}
-
-	if(isr){
-		errno = 0;
-		u = ptrace(PTRACE_PEEKUSER, map->pid, laddr, 0);
-		if(errno)
-			goto ptraceerr;
-		switch(n){
-		case 1:
-			*(uint8*)v = u;
-			break;
-		case 2:
-			*(uint16*)v = u;
-			break;
-		case 4:
-			*(uint32*)v = u;
-			break;
-		case 8:
-			*(uint64*)v = u;
-			break;
-		default:
-			werrstr("bad register size");
-			return -1;
-		}
-	}else{
-		switch(n){
-		case 1:
-			u = *(uint8*)v;
-			break;
-		case 2:
-			u = *(uint16*)v;
-			break;
-		case 4:
-			u = *(uint32*)v;
-			break;
-		case 8:
-			u = *(uint64*)v;
-			break;
-		default:
-			werrstr("bad register size");
-			return -1;
-		}
-		if(ptrace(PTRACE_POKEUSER, map->pid, laddr, (void*)(uintptr)u) < 0)
-			goto ptraceerr;
-	}
-	return 0;
-
-ptraceerr:
-	werrstr("ptrace %s register laddr=%d pid=%d n=%d: %r", isr ? "read" : "write", laddr, map->pid, n);
-	return -1;
-}
-
-char*
-procstatus(int pid)
-{
-	LinuxThread *t;
-
-	t = findthread(pid);
-	if(t == nil)
-		return "???";
-
-	return statestr[t->state];
-}