1 #ifndef _MACH_H_
2 #define _MACH_H_ 1
3 #if defined(__cplusplus)
4 extern "C" { 
5 #endif
6 
7 AUTOLIB(mach)
8 
9 /*
10  * Architecture-dependent application data.
11  * 
12  * The code assumes that ulong is big enough to hold
13  * an address on any system of interest as well as any
14  * register.  Debugging 64-bit code on 32-bit machines
15  * will be interesting.
16  *
17  * Supported architectures:
18  *
19  *	MIPS R3000
20  *	Motorola 68020
21  *	Intel 386
22  * 	SPARC
23  *	PowerPC (limited)
24  *	ARM (limited)
25  *	Intel 960 (limited)
26  *	AT&T 3210 DSP (limited)
27  *	MIPS2 (R4000)
28  */
29 
30 typedef struct Fhdr Fhdr;
31 typedef struct Loc Loc;
32 typedef struct Mach Mach;
33 typedef struct Map Map;
34 typedef struct Regdesc Regdesc;
35 typedef struct Regs Regs;
36 typedef struct Seg Seg;
37 typedef struct Symbol Symbol;
38 typedef struct Symtype Symtype;
39 
40 typedef int (*Tracer)(Map*, Regs*, ulong, ulong, Symbol*, int);
41 
42 extern	Mach	*mach;
43 extern	Mach	*machcpu;
44 
45 /*
46  * Byte-order data layout manipulation.
47  * 	swap.c ieee.c
48  */
49 u16int	beswap2(u16int u);
50 u32int	beswap4(u32int u);
51 u64int	beswap8(u64int u);
52 int		beieeeftoa32(char*, uint, void*);
53 int		beieeeftoa64(char*, uint, void*);
54 int		beieeeftoa80(char*, uint, void*);
55 
56 u16int	leswap2(u16int u);
57 u32int	leswap4(u32int u);
58 u64int	leswap8(u64int u);
59 int		leieeeftoa32(char *a, uint n, void *v);
60 int		leieeeftoa64(char *a, uint n, void *v);
61 int		leieeeftoa80(char *a, uint n, void *v);
62 
63 u16int	beload2(uchar*);
64 u32int	beload4(uchar*);
65 u64int	beload8(uchar*);
66 
67 u16int	leload2(uchar*);
68 u32int	leload4(uchar*);
69 u64int	leload8(uchar*);
70 
71 int		ieeeftoa32(char *a, uint n, u32int u);
72 int		ieeeftoa64(char *a, uint n, u32int h, u32int u);
73 
74 /*
75  * Machine-independent access to an executable image.
76  *	map.c
77  */
78 struct Seg
79 {
80 	char		*name;
81 	char		*file;
82 	uchar	*p;
83 	int		fd;
84 	int		pid;
85 	ulong	base;
86 	ulong	size;
87 	ulong	offset;
88 	int		(*rw)(Map*, Seg*, ulong, void*, uint, int);
89 };
90 
91 struct Map
92 {
93 	int		nseg;
94 	Seg		*seg;
95 };
96 
97 struct Regs
98 {
99 	int		(*rw)(Regs*, char*, ulong*, int);
100 };
101 
102 typedef struct UregRegs UregRegs;
103 struct UregRegs
104 {
105 	Regs		r;
106 	uchar	*ureg;
107 };
108 int		_uregrw(Regs*, char*, ulong*, int);
109 
110 typedef struct PidRegs PidRegs;
111 struct PidRegs
112 {
113 	Regs		r;
114 	int		pid;
115 };
116 
117 Map*	allocmap(void);
118 int		addseg(Map *map, Seg seg);
119 int		findseg(Map *map, char *name, char *file);
120 int		addrtoseg(Map *map, ulong addr, Seg *seg);
121 int		addrtosegafter(Map *map, ulong addr, Seg *seg);
122 void		removeseg(Map *map, int i);
123 void		freemap(Map*);
124 
125 int		get1(Map *map, ulong addr, uchar *a, uint n);
126 int		get2(Map *map, ulong addr, u16int *u);
127 int		get4(Map *map, ulong addr, u32int *u);
128 int		get8(Map *map, ulong addr, u64int *u);
129 
130 int		put1(Map *map, ulong addr, uchar *a, uint n);
131 int		put2(Map *map, ulong addr, u16int u);
132 int		put4(Map *map, ulong addr, u32int u);
133 int		put8(Map *map, ulong addr, u64int u);
134 
135 int		rget(Regs*, char*, ulong*);
136 int		rput(Regs*, char*, ulong);
137 
138 /* 
139  * A location is either a memory address or a register.
140  * It is useful to be able to specify constant values that
141  * originate from outside the register set and memory,
142  * hence LCONST.  If the register values are known, then
143  * we can dispense with LOFFSET, but it's useful to be able
144  * to look up local symbols (via findlsym) with locations
145  * like 8(BP).
146  *
147  *	loc.c
148  */
149 
150 enum
151 {
152 	/* location type */
153 	LNONE,
154 	LREG,		/* register */
155 	LADDR,		/* absolute address */
156 	LCONST,		/* constant (an anonymous readonly location) */
157 	LOFFSET		/* dereference offset + register ptr */
158 };
159 
160 struct Loc
161 {
162 	uint type;		/* LNONE, ... */
163 	char *reg;		/* LREG */
164 	ulong addr;	/* LADDR, CONST */
165 	long offset;	/* LOFFSET */
166 };
167 
168 int		lget1(Map *map, Regs *regs, Loc loc, uchar *a, uint n);
169 int		lget2(Map *map, Regs *regs, Loc loc, u16int *v);
170 int		lget4(Map *map, Regs *regs, Loc loc, u32int *v);
171 int		lget8(Map *map, Regs *regs, Loc loc, u64int *v);
172 
173 int		lput1(Map *map, Regs *regs, Loc loc, uchar *a, uint n);
174 int		lput2(Map *map, Regs *regs, Loc loc, u16int v);
175 int		lput4(Map *map, Regs *regs, Loc loc, u32int v);
176 int		lput8(Map *map, Regs *regs, Loc loc, u64int v);
177 
178 Loc		locnone(void);
179 Loc		locaddr(ulong addr);
180 Loc		locconst(ulong con);
181 Loc		locreg(char*);
182 Loc		locindir(char*, long);
183 
184 /* 
185  * Executable file parsing.
186  *
187  * An Fhdr represents an open file image.
188  * The contents are a grab bag of constants used for the
189  * various file types.  Not all elements are used by all
190  * file types.
191  *
192  *	crackadotplan9.c crackadotunix.c
193  *	crackelf.c crackdwarf.c
194  */
195 enum
196 {
197 	/* file types */
198 	FNONE,
199 	FEXEC,		/* executable image */
200 	FLIB,			/* library */
201 	FOBJ,		/* object file */
202 	FRELOC,		/* relocatable executable */
203 	FSHLIB,		/* shared library */
204 	FSHOBJ,		/* shared object */
205 	FCORE,		/* core dump */
206 	FBOOT,		/* bootable image */
207 	FKERNEL,		/* kernel image */
208 	NFTYPE,
209 
210 	/* abi types */
211 	ANONE = 0,
212 	APLAN9,
213 	ALINUX,
214 	AFREEBSD,
215 	AMACH,
216 	NATYPE
217 };
218 
219 /* I wish this could be kept in stabs.h */
220 struct Stab
221 {
222 	uchar *stabbase;
223 	uint stabsize;
224 	char *strbase;
225 	uint strsize;
226 	u16int (*e2)(uchar*);
227 	u32int (*e4)(uchar*);
228 };
229 
230 struct Fhdr
231 {
232 	int		fd;			/* file descriptor */
233 	char		*filename;		/* file name */
234 	Mach	*mach;		/* machine */
235 	char		*mname;		/* 386, power, ... */	
236 	uint		mtype;		/* machine type M386, ... */
237 	char		*fname;		/* core, executable, boot image, ... */
238 	uint		ftype;		/* file type FCORE, ... */
239 	char		*aname;		/* abi name */
240 	uint		atype;		/* abi type ALINUX, ... */
241 
242 	ulong	magic;		/* magic number */
243 	ulong	txtaddr;		/* text address */
244 	ulong	entry;		/* entry point */
245 	ulong	txtsz;		/* text size */
246 	ulong	txtoff;		/* text offset in file */
247 	ulong	dataddr;		/* data address */
248 	ulong	datsz;		/* data size */
249 	ulong	datoff;		/* data offset in file */
250 	ulong	bsssz;		/* bss size */
251 	ulong	symsz;		/* symbol table size */
252 	ulong	symoff;		/* symbol table offset in file */
253 	ulong	sppcsz;		/* size of sp-pc table */
254 	ulong	sppcoff;		/* offset of sp-pc table in file */
255 	ulong	lnpcsz;		/* size of line number-pc table */
256 	ulong	lnpcoff;		/* size of line number-pc table */
257 	void		*elf;			/* handle to elf image */
258 	void		*dwarf;		/* handle to dwarf image */
259 	void		*macho;		/* handle to mach-o image */
260 	struct Stab	stabs;
261 	uint		pid;			/* for core files */
262 	char		*prog;		/* program name, for core files */
263 	char		*cmdline;		/* command-line that produced core */
264 	struct	{			/* thread state for core files */
265 		uint	id;
266 		void	*ureg;
267 	} *thread;
268 	uint		nthread;
269 
270 	/* private */
271 	Symbol	*sym;		/* cached list of symbols */
272 	Symbol	**byname;
273 	Symbol	**byxname;
274 	uint		nsym;
275 	Symbol	*esym;		/* elf symbols */
276 	uint		nesym;
277 	ulong	base;		/* base address for relocatables */
278 	Fhdr		*next;		/* link to next fhdr (internal) */
279 
280 	/* file mapping */
281 	int		(*map)(Fhdr*, ulong, Map*, Regs**);
282 
283 	/* debugging symbol access; see below */
284 	int		(*syminit)(Fhdr*);
285 	void		(*symclose)(Fhdr*);
286 
287 	int		(*pc2file)(Fhdr*, ulong, char*, uint, ulong*);
288 	int		(*file2pc)(Fhdr*, char*, ulong, ulong*);
289 	int		(*line2pc)(Fhdr*, ulong, ulong, ulong*);
290 
291 	int		(*lookuplsym)(Fhdr*, Symbol*, char*, Symbol*);
292 	int		(*indexlsym)(Fhdr*, Symbol*, uint, Symbol*);
293 	int		(*findlsym)(Fhdr*, Symbol*, Loc, Symbol*);
294 
295 	int		(*unwind)(Fhdr*, Map*, Regs*, ulong*, Symbol*);
296 };
297 
298 Fhdr*	crackhdr(char *file, int mode);
299 void		uncrackhdr(Fhdr *hdr);
300 int		crackelf(int fd, Fhdr *hdr);
301 int		crackmacho(int fd, Fhdr *hdr);
302 Regs*	coreregs(Fhdr*, uint);
303 
304 int		symopen(Fhdr*);
305 int		symdwarf(Fhdr*);
306 int		symelf(Fhdr*);
307 int		symstabs(Fhdr*);
308 int		symmacho(Fhdr*);
309 void		symclose(Fhdr*);
310 
311 int		mapfile(Fhdr *fp, ulong base, Map *map, Regs **regs);
312 void		unmapfile(Fhdr *fp, Map *map);
313 
314 /*
315  * Process manipulation.
316  */
317 int		mapproc(int pid, Map *map, Regs **regs);
318 void		unmapproc(Map *map);
319 int		detachproc(int pid);
320 int		ctlproc(int pid, char *msg);
321 int		procnotes(int pid, char ***notes);
322 char*	proctextfile(int pid);
323 
324 /*
325  * Command-line debugger help
326  */
327 extern Fhdr *symhdr;
328 extern Fhdr *corhdr;
329 extern char *symfil;
330 extern char *corfil;
331 extern int corpid;
332 extern Regs *correg;
333 extern Map *symmap;
334 extern Map *cormap;
335 
336 int		attachproc(int pid);
337 int		attachcore(Fhdr *hdr);
338 int		attachargs(int argc, char **argv, int omode, int);
339 int		attachdynamic(int);
340 /*
341  * Machine descriptions.
342  *
343  *	mach.c
344  *	mach386.c dis386.c
345  *	machsparc.c dissparc.c
346  *	...
347  */
348 
349 /*
350  * Register sets.  The Regs are opaque, accessed by using
351  * the reglist (and really the accessor functions).
352  */
353 enum
354 {
355 	/* must be big enough for all machine register sets */
356 	REGSIZE = 256,
357 
358 	RINT = 0<<0,
359 	RFLT = 1<<0,
360 	RRDONLY = 1<<1
361 };
362 
363 struct Regdesc
364 {
365 	char		*name;		/* register name */
366 	uint		offset;		/* offset in b */
367 	uint		flags;		/* RINT/RFLT/RRDONLY */
368 	uint		format;		/* print format: 'x', 'X', 'f', 'z', 'Z' */
369 };
370 
371 enum
372 {
373 	/* machine types */
374 	MNONE,
375 	MMIPS,		/* MIPS R3000 */
376 	MSPARC,		/* SUN SPARC */
377 	M68000,		/* Motorola 68000 */
378 	M386,		/* Intel 32-bit x86*/
379 	M960,		/* Intel 960 */
380 	M3210,		/* AT&T 3210 DSP */
381 	MMIPS2,		/* MIPS R4000 */
382 	M29000,		/* AMD 29000 */
383 	MARM,		/* ARM */
384 	MPOWER,		/* PowerPC */
385 	MALPHA,		/* DEC/Compaq Alpha */
386 	NMTYPE
387 };
388 
389 struct Mach
390 {
391 	char		*name;		/* "386", ... */
392 	uint		type;			/* M386, ... */
393 	Regdesc	*reglist;		/* register set */
394 	uint		regsize;		/* size of register set in bytes */
395 	uint		fpregsize;		/* size of fp register set in bytes */
396 	char		*pc;			/* name of program counter */
397 	char		*sp;			/* name of stack pointer */
398 	char		*fp;			/* name of frame pointer */
399 	char		*link;		/* name of link register */
400 	char		*sbreg;		/* name of static base */
401 	ulong	sb;			/* value of static base */
402 	uint		pgsize;		/* page size */
403 	ulong	kbase;		/* kernel base address for Plan 9 */
404 	ulong	ktmask;		/* ktzero = kbase & ~ktmask */
405 	uint		pcquant;		/* pc quantum */
406 	uint		szaddr;		/* size of pointer in bytes */
407 	uint		szreg;		/* size of integer register */
408 	uint		szfloat;		/* size of float */
409 	uint		szdouble;		/* size of double */
410 	char**	windreg;		/* unwinding registers */
411 	uint		nwindreg;
412 
413 	uchar	bpinst[4];		/* break point instruction */
414 	uint		bpsize;		/* size of bp instruction */
415 
416 	int		(*foll)(Map*, Regs*, ulong, ulong*);	/* follow set */
417 	char*	(*exc)(Map*, Regs*);		/* last exception */
418 	int		(*unwind)(Map*, Regs*, ulong*, Symbol*);
419 
420 	/* cvt to local byte order */
421 	u16int	(*swap2)(u16int);
422 	u32int	(*swap4)(u32int);
423 	u64int	(*swap8)(u64int);
424 	int		(*ftoa32)(char*, uint, void*);
425 	int		(*ftoa64)(char*, uint, void*);
426 	int		(*ftoa80)(char*, uint, void*);
427 
428 	/* disassembly */
429 	int		(*das)(Map*, ulong, char, char*, int);	/* symbolic */
430 	int		(*kendas)(Map*, ulong, char, char*, int);	/* symbolic */
431 	int		(*codas)(Map*, ulong, char, char*, int);
432 	int		(*hexinst)(Map*, ulong, char*, int);	/* hex */
433 	int		(*instsize)(Map*, ulong);	/* instruction size */
434 };
435 
436 Mach	*machbyname(char*);
437 Mach	*machbytype(uint);
438 
439 extern	Mach	mach386;
440 extern	Mach	machsparc;
441 extern	Mach	machmips;
442 extern	Mach	machpower;
443 
444 /*
445  * Debugging symbols and type information.
446  * (Not all objects include type information.)
447  *
448  *	sym.c
449  */
450 
451 enum
452 {
453 	/* symbol table classes */
454 	CNONE,
455 	CAUTO,		/* stack variable */
456 	CPARAM,		/* function parameter */
457 	CTEXT,		/* text segment */
458 	CDATA,		/* data segment */
459 	CANY
460 };
461 
462 struct Symbol
463 {
464 	char		*name;		/* name of symbol */
465 	char		*xname;		/* demangled name */
466 
467 	/* Symtype	*typedesc;	/* type info, if any */
468 	Loc		loc;			/* location of symbol */
469 	Loc		hiloc;		/* location of end of symbol */
470 	char		class;		/* CAUTO, ... */
471 	char		type;			/* type letter from a.out.h */
472 	Fhdr		*fhdr;		/* where did this come from? */
473 	uint		index;		/* in by-address list */
474 
475 	/* private use by various symbol implementations */
476 	union {
477 		struct {
478 			uint unit;
479 			uint uoff;
480 		} dwarf;
481 		struct {
482 			uint i;
483 			uint locals;
484 			char *dir;
485 			char *file;
486 			schar frameptr;
487 			uint framesize;
488 		} stabs;
489 	} u;
490 	
491 	void *aux;	/* for use by client */
492 };
493 
494 /* look through all currently cracked Fhdrs calling their fns */
495 int		pc2file(ulong pc, char *file, uint nfile, ulong *line);
496 int		file2pc(char *file, ulong line, ulong *addr);
497 int		line2pc(ulong basepc, ulong line, ulong *pc);
498 int		fnbound(ulong pc, ulong *bounds);
499 int		fileline(ulong pc, char *a, uint n);
500 int		pc2line(ulong pc, ulong *line);
501 
502 int		lookupsym(char *fn, char *var, Symbol *s);
503 int		indexsym(uint ndx, Symbol *s);
504 int		findsym(Loc loc, uint class, Symbol *s);
505 int		findexsym(Fhdr*, uint, Symbol*);
506 
507 int		lookuplsym(Symbol *s1, char *name, Symbol *s2);
508 int		indexlsym(Symbol *s1, uint ndx, Symbol *s2);
509 int		findlsym(Symbol *s1, Loc loc, Symbol *s);
510 int		symoff(char *a, uint n, ulong addr, uint class);
511 int		unwindframe(Map *map, Regs *regs, ulong *next, Symbol*);
512 
513 void		_addhdr(Fhdr*);
514 void		_delhdr(Fhdr*);
515 extern Fhdr*	fhdrlist;
516 Fhdr*	findhdr(char*);
517 
518 Symbol*	flookupsym(Fhdr*, char*);
519 Symbol*	ffindsym(Fhdr*, Loc, uint);
520 Symbol*	_addsym(Fhdr*, Symbol*);
521 
522 char*	demangle(char*, char*, int);
523 char*	demanglegcc3(char*, char*);
524 char*	demanglegcc2(char*, char*);
525 /*
526  * Stack frame walking.
527  *
528  *	frame.c
529  */
530 int		stacktrace(Map*, Regs*, Tracer);
531 int		windindex(char*);
532 Loc*		windreglocs(void);
533 
534 /*
535  * Debugger help.
536  */
537 int		localaddr(Map *map, Regs *regs, char *fn, char *var, ulong *val);
538 int		fpformat(Map *map, Regdesc *reg, char *a, uint n, uint code);
539 char*	_hexify(char*, ulong, int);
540 int		locfmt(Fmt*);
541 int		loccmp(Loc*, Loc*);
542 int		locsimplify(Map *map, Regs *regs, Loc loc, Loc *newloc);
543 Regdesc*	regdesc(char*);
544 
545 extern int machdebug;
546 #if defined(__cplusplus)
547 }
548 #endif
549 #endif