add mach.h

1 files changed, 504 insertions, 0 deletions

diff --git a/include/mach.h b/include/mach.h
new file mode 100644
index 00000000..2a1b168a
--- /dev/null
+++ b/include/mach.h
@@ -0,0 +1,504 @@
+/*
+ * Architecture-dependent application data.
+ * 
+ * The code assumes that ulong is big enough to hold
+ * an address on any system of interest as well as any
+ * register.  Debugging 64-bit code on 32-bit machines
+ * will be interesting.
+ *
+ * Supported architectures:
+ *
+ *	MIPS R3000
+ *	Motorola 68020
+ *	Intel 386
+ * 	SPARC
+ *	PowerPC (limited)
+ *	ARM (limited)
+ *	Intel 960 (limited)
+ *	AT&T 3210 DSP (limited)
+ *	MIPS2 (R4000)
+ */
+
+typedef struct Fhdr Fhdr;
+typedef struct Loc Loc;
+typedef struct Mach Mach;
+typedef struct Map Map;
+typedef struct Regdesc Regdesc;
+typedef struct Regs Regs;
+typedef struct Seg Seg;
+typedef struct Symbol Symbol;
+typedef struct Symtype Symtype;
+
+typedef int (*Tracer)(Map*, Regs*, ulong, ulong, Symbol*, int);
+
+extern	Mach	*mach;
+extern	Mach	*machcpu;
+
+/*
+ * Byte-order data layout manipulation.
+ * 	swap.c ieee.c
+ */
+u16int	beswap2(u16int u);
+u32int	beswap4(u32int u);
+u64int	beswap8(u64int u);
+int		beieeeftoa32(char*, uint, void*);
+int		beieeeftoa64(char*, uint, void*);
+int		beieeeftoa80(char*, uint, void*);
+
+u16int	leswap2(u16int u);
+u32int	leswap4(u32int u);
+u64int	leswap8(u64int u);
+int		leieeeftoa32(char *a, uint n, void *v);
+int		leieeeftoa64(char *a, uint n, void *v);
+int		leieeeftoa80(char *a, uint n, void *v);
+
+u16int	beload2(uchar*);
+u32int	beload4(uchar*);
+u64int	beload8(uchar*);
+
+u16int	leload2(uchar*);
+u32int	leload4(uchar*);
+u64int	leload8(uchar*);
+
+int		ieeeftoa32(char *a, uint n, u32int u);
+int		ieeeftoa64(char *a, uint n, u32int h, u32int u);
+
+/*
+ * Machine-independent access to an executable image.
+ *	map.c
+ */
+struct Seg
+{
+	char		*name;
+	char		*file;
+	uchar	*p;
+	int		fd;
+	int		pid;
+	ulong	base;
+	ulong	size;
+	ulong	offset;
+	int		(*rw)(Map*, Seg*, ulong, void*, uint, int);
+};
+
+struct Map
+{
+	int		nseg;
+	Seg		*seg;
+};
+
+struct Regs
+{
+	int		(*rw)(Regs*, char*, ulong*, int);
+};
+
+typedef struct UregRegs UregRegs;
+struct UregRegs
+{
+	Regs		r;
+	uchar	*ureg;
+};
+int		_uregrw(Regs*, char*, ulong*, int);
+
+typedef struct PidRegs PidRegs;
+struct PidRegs
+{
+	Regs		r;
+	int		pid;
+};
+
+Map*	allocmap(void);
+int		addseg(Map *map, Seg seg);
+int		findseg(Map *map, char *name, char *file);
+int		addrtoseg(Map *map, ulong addr, Seg *seg);
+int		addrtosegafter(Map *map, ulong addr, Seg *seg);
+void		removeseg(Map *map, int i);
+void		freemap(Map*);
+
+int		get1(Map *map, ulong addr, uchar *a, uint n);
+int		get2(Map *map, ulong addr, u16int *u);
+int		get4(Map *map, ulong addr, u32int *u);
+int		get8(Map *map, ulong addr, u64int *u);
+
+int		put1(Map *map, ulong addr, uchar *a, uint n);
+int		put2(Map *map, ulong addr, u16int u);
+int		put4(Map *map, ulong addr, u32int u);
+int		put8(Map *map, ulong addr, u64int u);
+
+int		rget(Regs*, char*, ulong*);
+int		rput(Regs*, char*, ulong);
+
+/* 
+ * A location is either a memory address or a register.
+ * It is useful to be able to specify constant values that
+ * originate from outside the register set and memory,
+ * hence LCONST.  If the register values are known, then
+ * we can dispense with LOFFSET, but it's useful to be able
+ * to look up local symbols (via findlsym) with locations
+ * like 8(BP).
+ *
+ *	loc.c
+ */
+
+enum
+{
+	/* location type */
+	LNONE,
+	LREG,		/* register */
+	LADDR,		/* absolute address */
+	LCONST,		/* constant (an anonymous readonly location) */
+	LOFFSET,		/* dereference offset + register ptr */
+};
+
+struct Loc
+{
+	uint type;		/* LNONE, ... */
+	char *reg;		/* LREG */
+	ulong addr;	/* LADDR, CONST */
+	long offset;	/* LOFFSET */
+};
+
+int		lget1(Map *map, Regs *regs, Loc loc, uchar *a, uint n);
+int		lget2(Map *map, Regs *regs, Loc loc, u16int *v);
+int		lget4(Map *map, Regs *regs, Loc loc, u32int *v);
+int		lget8(Map *map, Regs *regs, Loc loc, u64int *v);
+
+int		lput1(Map *map, Regs *regs, Loc loc, uchar *a, uint n);
+int		lput2(Map *map, Regs *regs, Loc loc, u16int v);
+int		lput4(Map *map, Regs *regs, Loc loc, u32int v);
+int		lput8(Map *map, Regs *regs, Loc loc, u64int v);
+
+Loc		locnone(void);
+Loc		locaddr(ulong addr);
+Loc		locconst(ulong con);
+Loc		locreg(char*);
+Loc		locindir(char*, long);
+
+/* 
+ * Executable file parsing.
+ *
+ * An Fhdr represents an open file image.
+ * The contents are a grab bag of constants used for the
+ * various file types.  Not all elements are used by all
+ * file types.
+ *
+ *	crackadotplan9.c crackadotunix.c
+ *	crackelf.c crackdwarf.c
+ */
+enum
+{
+	/* file types */
+	FNONE,
+	FEXEC,		/* executable image */
+	FLIB,			/* library */
+	FOBJ,		/* object file */
+	FRELOC,		/* relocatable executable */
+	FSHLIB,		/* shared library */
+	FSHOBJ,		/* shared object */
+	FCORE,		/* core dump */
+	FBOOT,		/* bootable image */
+	FKERNEL,		/* kernel image */
+	NFTYPE,
+
+	/* abi types */
+	ANONE = 0,
+	APLAN9,
+	ALINUX,
+	AFREEBSD,
+	AMACH,
+	NATYPE
+};
+
+/* I wish this could be kept in stabs.h */
+struct Stab
+{
+	uchar *stabbase;
+	uint stabsize;
+	char *strbase;
+	uint strsize;
+	u16int (*e2)(uchar*);
+	u32int (*e4)(uchar*);
+};
+
+struct Fhdr
+{
+	int		fd;			/* file descriptor */
+	char		*filename;		/* file name */
+	Mach	*mach;		/* machine */
+	char		*mname;		/* 386, power, ... */	
+	uint		mtype;		/* machine type M386, ... */
+	char		*fname;		/* core, executable, boot image, ... */
+	uint		ftype;		/* file type FCORE, ... */
+	char		*aname;		/* abi name */
+	uint		atype;		/* abi type ALINUX, ... */
+
+	ulong	magic;		/* magic number */
+	ulong	txtaddr;		/* text address */
+	ulong	entry;		/* entry point */
+	ulong	txtsz;		/* text size */
+	ulong	txtoff;		/* text offset in file */
+	ulong	dataddr;		/* data address */
+	ulong	datsz;		/* data size */
+	ulong	datoff;		/* data offset in file */
+	ulong	bsssz;		/* bss size */
+	ulong	symsz;		/* symbol table size */
+	ulong	symoff;		/* symbol table offset in file */
+	ulong	sppcsz;		/* size of sp-pc table */
+	ulong	sppcoff;		/* offset of sp-pc table in file */
+	ulong	lnpcsz;		/* size of line number-pc table */
+	ulong	lnpcoff;		/* size of line number-pc table */
+	void		*elf;			/* handle to elf image */
+	void		*dwarf;		/* handle to dwarf image */
+	void		*macho;		/* handle to mach-o image */
+	struct Stab	stabs;
+
+	/* private */
+	Symbol	*sym;		/* cached list of symbols */
+	Symbol	**byname;
+	uint		nsym;
+	Symbol	*esym;		/* elf symbols */
+	Symbol	**ebyname;
+	uint		nesym;
+	ulong	base;		/* base address for relocatables */
+	Fhdr		*next;		/* link to next fhdr (internal) */
+
+	/* file mapping */
+	int		(*map)(Fhdr*, ulong, Map*, Regs**);
+
+	/* debugging symbol access; see below */
+	int		(*syminit)(Fhdr*);
+	void		(*symclose)(Fhdr*);
+
+	int		(*pc2file)(Fhdr*, ulong, char*, uint, ulong*);
+	int		(*file2pc)(Fhdr*, char*, ulong, ulong*);
+	int		(*line2pc)(Fhdr*, ulong, ulong, ulong*);
+
+	int		(*lookuplsym)(Fhdr*, Symbol*, char*, Symbol*);
+	int		(*indexlsym)(Fhdr*, Symbol*, uint, Symbol*);
+	int		(*findlsym)(Fhdr*, Symbol*, Loc, Symbol*);
+
+	int		(*unwind)(Fhdr*, Map*, Regs*, ulong*);
+};
+
+Fhdr*	crackhdr(char *file, int mode);
+void		uncrackhdr(Fhdr *hdr);
+int		crackelf(int fd, Fhdr *hdr);
+int		crackmacho(int fd, Fhdr *hdr);
+
+int		syminit(Fhdr*);
+int		symdwarf(Fhdr*);
+int		symelf(Fhdr*);
+int		symstabs(Fhdr*);
+int		symmacho(Fhdr*);
+
+int		mapfile(Fhdr *fp, ulong base, Map *map, Regs **regs);
+void		unmapfile(Fhdr *fp, Map *map);
+
+/*
+ * Process manipulation.
+ */
+int		mapproc(int pid, Map *map, Regs **regs);
+void		unmapproc(Map *map);
+int		detachproc(int pid);
+int		ctlproc(int pid, char *msg);
+int		procnotes(int pid, char ***notes);
+char*	proctextfile(int pid);
+
+/*
+ * Machine descriptions.
+ *
+ *	mach.c
+ *	mach386.c dis386.c
+ *	machsparc.c dissparc.c
+ *	...
+ */
+
+/*
+ * Register sets.  The Regs are opaque, accessed by using
+ * the reglist (and really the accessor functions).
+ */
+enum
+{
+	/* must be big enough for all machine register sets */
+	REGSIZE = 256,
+
+	RINT = 0<<0,
+	RFLT = 1<<0,
+	RRDONLY = 1<<1,
+};
+
+struct Regdesc
+{
+	char		*name;		/* register name */
+	uint		offset;		/* offset in b */
+	uint		flags;		/* RINT/RFLT/RRDONLY */
+	uint		format;		/* print format: 'x', 'X', 'f', 'z', 'Z' */
+};
+
+Regdesc*	regdesc(char*);
+
+enum
+{
+	/* machine types */
+	MNONE,
+	MMIPS,		/* MIPS R3000 */
+	MSPARC,		/* SUN SPARC */
+	M68000,		/* Motorola 68000 */
+	M386,		/* Intel 32-bit x86*/
+	M960,		/* Intel 960 */
+	M3210,		/* AT&T 3210 DSP */
+	MMIPS2,		/* MIPS R4000 */
+	M29000,		/* AMD 29000 */
+	MARM,		/* ARM */
+	MPOWER,		/* PowerPC */
+	MALPHA,		/* DEC/Compaq Alpha */
+	NMTYPE
+};
+
+struct Mach
+{
+	char		*name;		/* "386", ... */
+	uint		type;			/* M386, ... */
+	Regdesc	*reglist;		/* register set */
+	uint		regsize;		/* size of register set in bytes */
+	uint		fpregsize;		/* size of fp register set in bytes */
+	char		*pc;			/* name of program counter */
+	char		*sp;			/* name of stack pointer */
+	char		*fp;			/* name of frame pointer */
+	char		*link;		/* name of link register */
+	char		*sbreg;		/* name of static base */
+	ulong	sb;			/* value of static base */
+	uint		pgsize;		/* page size */
+	ulong	kbase;		/* kernel base address for Plan 9 */
+	ulong	ktmask;		/* ktzero = kbase & ~ktmask */
+	uint		pcquant;		/* pc quantum */
+	uint		szaddr;		/* size of pointer in bytes */
+	uint		szreg;		/* size of integer register */
+	uint		szfloat;		/* size of float */
+	uint		szdouble;		/* size of double */
+	char**	windreg;		/* unwinding registers */
+	uint		nwindreg;
+
+	uchar	bpinst[4];		/* break point instruction */
+	uint		bpsize;		/* size of bp instruction */
+
+	int		(*foll)(Map*, Regs*, ulong, ulong*);	/* follow set */
+	char*	(*exc)(Map*, Regs*);		/* last exception */
+	int		(*unwind)(Map*, Regs*, ulong*);
+
+	/* cvt to local byte order */
+	u16int	(*swap2)(u16int);
+	u32int	(*swap4)(u32int);
+	u64int	(*swap8)(u64int);
+	int		(*ftoa32)(char*, uint, void*);
+	int		(*ftoa64)(char*, uint, void*);
+	int		(*ftoa80)(char*, uint, void*);
+
+	/* disassembly */
+	int		(*das)(Map*, ulong, char, char*, int);	/* symbolic */
+	int		(*kendas)(Map*, ulong, char, char*, int);	/* symbolic */
+	int		(*codas)(Map*, ulong, char, char*, int);
+	int		(*hexinst)(Map*, ulong, char*, int);	/* hex */
+	int		(*instsize)(Map*, ulong);	/* instruction size */
+};
+
+Mach	*machbyname(char*);
+Mach	*machbytype(uint);
+
+extern	Mach	mach386;
+extern	Mach	machsparc;
+extern	Mach	machmips;
+extern	Mach	machpower;
+
+/*
+ * Debugging symbols and type information.
+ * (Not all objects include type information.)
+ *
+ *	sym.c
+ */
+
+enum
+{
+	/* symbol table classes */
+	CNONE,
+	CAUTO,		/* stack variable */
+	CPARAM,		/* function parameter */
+	CTEXT,		/* text segment */
+	CDATA,		/* data segment */
+	CANY,
+};
+
+struct Symbol
+{
+	char		*name;		/* name of symbol */
+	/* Symtype	*typedesc;	/* type info, if any */
+	Loc		loc;			/* location of symbol */
+	Loc		hiloc;		/* location of end of symbol */
+	char		class;		/* CAUTO, ... */
+	char		type;			/* type letter from a.out.h */
+	Fhdr		*fhdr;		/* where did this come from? */
+	uint		index;		/* in by-address list */
+
+	/* private use by various symbol implementations */
+	union {
+		struct {
+			uint unit;
+			uint uoff;
+		} dwarf;
+		struct {
+			uint i;
+			uint locals;
+			char *dir;
+			char *file;
+			char frameptr;
+			uint framesize;
+		} stabs;
+	} u;
+};
+
+/* look through all currently cracked Fhdrs calling their fns */
+int		pc2file(ulong pc, char *file, uint nfile, ulong *line);
+int		file2pc(char *file, ulong line, ulong *addr);
+int		line2pc(ulong basepc, ulong line, ulong *pc);
+int		fnbound(ulong pc, ulong *bounds);
+int		fileline(ulong pc, char *a, uint n);
+int		pc2line(ulong pc, ulong *line);
+
+int		lookupsym(char *fn, char *var, Symbol *s);
+int		indexsym(uint ndx, Symbol *s);
+int		findsym(Loc loc, uint class, Symbol *s);
+int		findexsym(Fhdr*, uint, Symbol*);
+
+int		lookuplsym(Symbol *s1, char *name, Symbol *s2);
+int		indexlsym(Symbol *s1, uint ndx, Symbol *s2);
+int		findlsym(Symbol *s1, Loc loc, Symbol *s);
+int		symoff(char *a, uint n, ulong addr, uint class);
+int		unwindframe(Map *map, Regs *regs, ulong *next);
+
+void		_addhdr(Fhdr*);
+void		_delhdr(Fhdr*);
+Fhdr*	fhdrlist;
+
+Symbol*	flookupsym(Fhdr*, char*);
+Symbol*	ffindsym(Fhdr*, Loc, uint);
+Symbol*	addsym(Fhdr*, Symbol*);
+
+/*
+ * Stack frame walking.
+ *
+ *	frame.c
+ */
+int		stacktrace(Map*, Regs*, Tracer);
+int		windindex(char*);
+Loc*		windreglocs(void);
+
+/*
+ * Debugger help.
+ */
+int		localaddr(Map *map, Regs *regs, char *fn, char *var, ulong *val);
+int		fpformat(Map *map, Regdesc *reg, char *a, uint n, uint code);
+char*	_hexify(char*, ulong, int);
+int		locfmt(Fmt*);
+int		loccmp(Loc*, Loc*);
+int		locsimplify(Map *map, Regs *regs, Loc loc, Loc *newloc);
+
+extern int machdebug;