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 	char		*txtfil;		/* text name, for core files */
258 	void		*elf;			/* handle to elf image */
259 	void		*dwarf;		/* handle to dwarf image */
260 	void		*macho;		/* handle to mach-o image */
261 	struct Stab	stabs;
262 
263 	/* private */
264 	Symbol	*sym;		/* cached list of symbols */
265 	Symbol	**byname;
266 	uint		nsym;
267 	Symbol	*esym;		/* elf symbols */
268 	Symbol	**ebyname;
269 	uint		nesym;
270 	ulong	base;		/* base address for relocatables */
271 	Fhdr		*next;		/* link to next fhdr (internal) */
272 
273 	/* file mapping */
274 	int		(*map)(Fhdr*, ulong, Map*, Regs**);
275 
276 	/* debugging symbol access; see below */
277 	int		(*syminit)(Fhdr*);
278 	void		(*symclose)(Fhdr*);
279 
280 	int		(*pc2file)(Fhdr*, ulong, char*, uint, ulong*);
281 	int		(*file2pc)(Fhdr*, char*, ulong, ulong*);
282 	int		(*line2pc)(Fhdr*, ulong, ulong, ulong*);
283 
284 	int		(*lookuplsym)(Fhdr*, Symbol*, char*, Symbol*);
285 	int		(*indexlsym)(Fhdr*, Symbol*, uint, Symbol*);
286 	int		(*findlsym)(Fhdr*, Symbol*, Loc, Symbol*);
287 
288 	int		(*unwind)(Fhdr*, Map*, Regs*, ulong*, Symbol*);
289 };
290 
291 Fhdr*	crackhdr(char *file, int mode);
292 void		uncrackhdr(Fhdr *hdr);
293 int		crackelf(int fd, Fhdr *hdr);
294 int		crackmacho(int fd, Fhdr *hdr);
295 
296 int		symopen(Fhdr*);
297 int		symdwarf(Fhdr*);
298 int		symelf(Fhdr*);
299 int		symstabs(Fhdr*);
300 int		symmacho(Fhdr*);
301 void		symclose(Fhdr*);
302 
303 int		mapfile(Fhdr *fp, ulong base, Map *map, Regs **regs);
304 void		unmapfile(Fhdr *fp, Map *map);
305 
306 /*
307  * Process manipulation.
308  */
309 int		mapproc(int pid, Map *map, Regs **regs);
310 void		unmapproc(Map *map);
311 int		detachproc(int pid);
312 int		ctlproc(int pid, char *msg);
313 int		procnotes(int pid, char ***notes);
314 char*	proctextfile(int pid);
315 
316 /*
317  * Command-line debugger help
318  */
319 extern Fhdr *symhdr;
320 extern Fhdr *corhdr;
321 extern char *symfil;
322 extern char *corfil;
323 extern int corpid;
324 extern Regs *correg;
325 extern Map *symmap;
326 extern Map *cormap;
327 
328 int		attachproc(int pid);
329 int		attachcore(Fhdr *hdr);
330 int		attachargs(int argc, char **argv, int omode);
331 
332 /*
333  * Machine descriptions.
334  *
335  *	mach.c
336  *	mach386.c dis386.c
337  *	machsparc.c dissparc.c
338  *	...
339  */
340 
341 /*
342  * Register sets.  The Regs are opaque, accessed by using
343  * the reglist (and really the accessor functions).
344  */
345 enum
346 {
347 	/* must be big enough for all machine register sets */
348 	REGSIZE = 256,
349 
350 	RINT = 0<<0,
351 	RFLT = 1<<0,
352 	RRDONLY = 1<<1,
353 };
354 
355 struct Regdesc
356 {
357 	char		*name;		/* register name */
358 	uint		offset;		/* offset in b */
359 	uint		flags;		/* RINT/RFLT/RRDONLY */
360 	uint		format;		/* print format: 'x', 'X', 'f', 'z', 'Z' */
361 };
362 
363 enum
364 {
365 	/* machine types */
366 	MNONE,
367 	MMIPS,		/* MIPS R3000 */
368 	MSPARC,		/* SUN SPARC */
369 	M68000,		/* Motorola 68000 */
370 	M386,		/* Intel 32-bit x86*/
371 	M960,		/* Intel 960 */
372 	M3210,		/* AT&T 3210 DSP */
373 	MMIPS2,		/* MIPS R4000 */
374 	M29000,		/* AMD 29000 */
375 	MARM,		/* ARM */
376 	MPOWER,		/* PowerPC */
377 	MALPHA,		/* DEC/Compaq Alpha */
378 	NMTYPE
379 };
380 
381 struct Mach
382 {
383 	char		*name;		/* "386", ... */
384 	uint		type;			/* M386, ... */
385 	Regdesc	*reglist;		/* register set */
386 	uint		regsize;		/* size of register set in bytes */
387 	uint		fpregsize;		/* size of fp register set in bytes */
388 	char		*pc;			/* name of program counter */
389 	char		*sp;			/* name of stack pointer */
390 	char		*fp;			/* name of frame pointer */
391 	char		*link;		/* name of link register */
392 	char		*sbreg;		/* name of static base */
393 	ulong	sb;			/* value of static base */
394 	uint		pgsize;		/* page size */
395 	ulong	kbase;		/* kernel base address for Plan 9 */
396 	ulong	ktmask;		/* ktzero = kbase & ~ktmask */
397 	uint		pcquant;		/* pc quantum */
398 	uint		szaddr;		/* size of pointer in bytes */
399 	uint		szreg;		/* size of integer register */
400 	uint		szfloat;		/* size of float */
401 	uint		szdouble;		/* size of double */
402 	char**	windreg;		/* unwinding registers */
403 	uint		nwindreg;
404 
405 	uchar	bpinst[4];		/* break point instruction */
406 	uint		bpsize;		/* size of bp instruction */
407 
408 	int		(*foll)(Map*, Regs*, ulong, ulong*);	/* follow set */
409 	char*	(*exc)(Map*, Regs*);		/* last exception */
410 	int		(*unwind)(Map*, Regs*, ulong*, Symbol*);
411 
412 	/* cvt to local byte order */
413 	u16int	(*swap2)(u16int);
414 	u32int	(*swap4)(u32int);
415 	u64int	(*swap8)(u64int);
416 	int		(*ftoa32)(char*, uint, void*);
417 	int		(*ftoa64)(char*, uint, void*);
418 	int		(*ftoa80)(char*, uint, void*);
419 
420 	/* disassembly */
421 	int		(*das)(Map*, ulong, char, char*, int);	/* symbolic */
422 	int		(*kendas)(Map*, ulong, char, char*, int);	/* symbolic */
423 	int		(*codas)(Map*, ulong, char, char*, int);
424 	int		(*hexinst)(Map*, ulong, char*, int);	/* hex */
425 	int		(*instsize)(Map*, ulong);	/* instruction size */
426 };
427 
428 Mach	*machbyname(char*);
429 Mach	*machbytype(uint);
430 
431 extern	Mach	mach386;
432 extern	Mach	machsparc;
433 extern	Mach	machmips;
434 extern	Mach	machpower;
435 
436 /*
437  * Debugging symbols and type information.
438  * (Not all objects include type information.)
439  *
440  *	sym.c
441  */
442 
443 enum
444 {
445 	/* symbol table classes */
446 	CNONE,
447 	CAUTO,		/* stack variable */
448 	CPARAM,		/* function parameter */
449 	CTEXT,		/* text segment */
450 	CDATA,		/* data segment */
451 	CANY,
452 };
453 
454 struct Symbol
455 {
456 	char		*name;		/* name of symbol */
457 	/* Symtype	*typedesc;	/* type info, if any */
458 	Loc		loc;			/* location of symbol */
459 	Loc		hiloc;		/* location of end of symbol */
460 	char		class;		/* CAUTO, ... */
461 	char		type;			/* type letter from a.out.h */
462 	Fhdr		*fhdr;		/* where did this come from? */
463 	uint		index;		/* in by-address list */
464 
465 	/* private use by various symbol implementations */
466 	union {
467 		struct {
468 			uint unit;
469 			uint uoff;
470 		} dwarf;
471 		struct {
472 			uint i;
473 			uint locals;
474 			char *dir;
475 			char *file;
476 			char frameptr;
477 			uint framesize;
478 		} stabs;
479 	} u;
480 };
481 
482 /* look through all currently cracked Fhdrs calling their fns */
483 int		pc2file(ulong pc, char *file, uint nfile, ulong *line);
484 int		file2pc(char *file, ulong line, ulong *addr);
485 int		line2pc(ulong basepc, ulong line, ulong *pc);
486 int		fnbound(ulong pc, ulong *bounds);
487 int		fileline(ulong pc, char *a, uint n);
488 int		pc2line(ulong pc, ulong *line);
489 
490 int		lookupsym(char *fn, char *var, Symbol *s);
491 int		indexsym(uint ndx, Symbol *s);
492 int		findsym(Loc loc, uint class, Symbol *s);
493 int		findexsym(Fhdr*, uint, Symbol*);
494 
495 int		lookuplsym(Symbol *s1, char *name, Symbol *s2);
496 int		indexlsym(Symbol *s1, uint ndx, Symbol *s2);
497 int		findlsym(Symbol *s1, Loc loc, Symbol *s);
498 int		symoff(char *a, uint n, ulong addr, uint class);
499 int		unwindframe(Map *map, Regs *regs, ulong *next, Symbol*);
500 
501 void		_addhdr(Fhdr*);
502 void		_delhdr(Fhdr*);
503 extern Fhdr*	fhdrlist;
504 Fhdr*	findhdr(char*);
505 
506 Symbol*	flookupsym(Fhdr*, char*);
507 Symbol*	ffindsym(Fhdr*, Loc, uint);
508 Symbol*	_addsym(Fhdr*, Symbol*);
509 
510 /*
511  * Stack frame walking.
512  *
513  *	frame.c
514  */
515 int		stacktrace(Map*, Regs*, Tracer);
516 int		windindex(char*);
517 Loc*		windreglocs(void);
518 
519 /*
520  * Debugger help.
521  */
522 int		localaddr(Map *map, Regs *regs, char *fn, char *var, ulong *val);
523 int		fpformat(Map *map, Regdesc *reg, char *a, uint n, uint code);
524 char*	_hexify(char*, ulong, int);
525 int		locfmt(Fmt*);
526 int		loccmp(Loc*, Loc*);
527 int		locsimplify(Map *map, Regs *regs, Loc loc, Loc *newloc);
528 Regdesc*	regdesc(char*);
529 
530 struct ps_prochandle
531 {
532 	int pid;
533 };
534 
535 extern int machdebug;
536 #if defined(__cplusplus)
537 }
538 #endif
539 #endif