3 #if defined(__cplusplus)
10 * Architecture-dependent application data.
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.
17 * Supported architectures:
26 * AT&T 3210 DSP (limited)
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;
40 typedef int (*Tracer)(Map*, Regs*, ulong, ulong, Symbol*, int);
46 * Byte-order data layout manipulation.
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*);
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);
63 u16int beload2(uchar*);
64 u32int beload4(uchar*);
65 u64int beload8(uchar*);
67 u16int leload2(uchar*);
68 u32int leload4(uchar*);
69 u64int leload8(uchar*);
71 int ieeeftoa32(char *a, uint n, u32int u);
72 int ieeeftoa64(char *a, uint n, u32int h, u32int u);
75 * Machine-independent access to an executable image.
88 int (*rw)(Map*, Seg*, ulong, void*, uint, int);
99 int (*rw)(Regs*, char*, ulong*, int);
102 typedef struct UregRegs UregRegs;
108 int _uregrw(Regs*, char*, ulong*, int);
110 typedef struct PidRegs PidRegs;
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);
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);
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);
135 int rget(Regs*, char*, ulong*);
136 int rput(Regs*, char*, ulong);
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
155 LADDR, /* absolute address */
156 LCONST, /* constant (an anonymous readonly location) */
157 LOFFSET, /* dereference offset + register ptr */
162 uint type; /* LNONE, ... */
163 char *reg; /* LREG */
164 ulong addr; /* LADDR, CONST */
165 long offset; /* LOFFSET */
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);
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);
179 Loc locaddr(ulong addr);
180 Loc locconst(ulong con);
182 Loc locindir(char*, long);
185 * Executable file parsing.
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
192 * crackadotplan9.c crackadotunix.c
193 * crackelf.c crackdwarf.c
199 FEXEC, /* executable image */
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 */
219 /* I wish this could be kept in stabs.h */
226 u16int (*e2)(uchar*);
227 u32int (*e4)(uchar*);
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, ... */
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 */
264 Symbol *sym; /* cached list of symbols */
267 Symbol *esym; /* elf symbols */
270 ulong base; /* base address for relocatables */
271 Fhdr *next; /* link to next fhdr (internal) */
274 int (*map)(Fhdr*, ulong, Map*, Regs**);
276 /* debugging symbol access; see below */
277 int (*syminit)(Fhdr*);
278 void (*symclose)(Fhdr*);
280 int (*pc2file)(Fhdr*, ulong, char*, uint, ulong*);
281 int (*file2pc)(Fhdr*, char*, ulong, ulong*);
282 int (*line2pc)(Fhdr*, ulong, ulong, ulong*);
284 int (*lookuplsym)(Fhdr*, Symbol*, char*, Symbol*);
285 int (*indexlsym)(Fhdr*, Symbol*, uint, Symbol*);
286 int (*findlsym)(Fhdr*, Symbol*, Loc, Symbol*);
288 int (*unwind)(Fhdr*, Map*, Regs*, ulong*, Symbol*);
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);
302 int mapfile(Fhdr *fp, ulong base, Map *map, Regs **regs);
303 void unmapfile(Fhdr *fp, Map *map);
306 * Process manipulation.
308 int mapproc(int pid, Map *map, Regs **regs);
309 void unmapproc(Map *map);
310 int detachproc(int pid);
311 int ctlproc(int pid, char *msg);
312 int procnotes(int pid, char ***notes);
313 char* proctextfile(int pid);
316 * Command-line debugger help
327 int attachproc(int pid);
328 int attachcore(Fhdr *hdr);
329 int attachargs(int argc, char **argv, int omode);
332 * Machine descriptions.
336 * machsparc.c dissparc.c
341 * Register sets. The Regs are opaque, accessed by using
342 * the reglist (and really the accessor functions).
346 /* must be big enough for all machine register sets */
356 char *name; /* register name */
357 uint offset; /* offset in b */
358 uint flags; /* RINT/RFLT/RRDONLY */
359 uint format; /* print format: 'x', 'X', 'f', 'z', 'Z' */
366 MMIPS, /* MIPS R3000 */
367 MSPARC, /* SUN SPARC */
368 M68000, /* Motorola 68000 */
369 M386, /* Intel 32-bit x86*/
370 M960, /* Intel 960 */
371 M3210, /* AT&T 3210 DSP */
372 MMIPS2, /* MIPS R4000 */
373 M29000, /* AMD 29000 */
375 MPOWER, /* PowerPC */
376 MALPHA, /* DEC/Compaq Alpha */
382 char *name; /* "386", ... */
383 uint type; /* M386, ... */
384 Regdesc *reglist; /* register set */
385 uint regsize; /* size of register set in bytes */
386 uint fpregsize; /* size of fp register set in bytes */
387 char *pc; /* name of program counter */
388 char *sp; /* name of stack pointer */
389 char *fp; /* name of frame pointer */
390 char *link; /* name of link register */
391 char *sbreg; /* name of static base */
392 ulong sb; /* value of static base */
393 uint pgsize; /* page size */
394 ulong kbase; /* kernel base address for Plan 9 */
395 ulong ktmask; /* ktzero = kbase & ~ktmask */
396 uint pcquant; /* pc quantum */
397 uint szaddr; /* size of pointer in bytes */
398 uint szreg; /* size of integer register */
399 uint szfloat; /* size of float */
400 uint szdouble; /* size of double */
401 char** windreg; /* unwinding registers */
404 uchar bpinst[4]; /* break point instruction */
405 uint bpsize; /* size of bp instruction */
407 int (*foll)(Map*, Regs*, ulong, ulong*); /* follow set */
408 char* (*exc)(Map*, Regs*); /* last exception */
409 int (*unwind)(Map*, Regs*, ulong*, Symbol*);
411 /* cvt to local byte order */
412 u16int (*swap2)(u16int);
413 u32int (*swap4)(u32int);
414 u64int (*swap8)(u64int);
415 int (*ftoa32)(char*, uint, void*);
416 int (*ftoa64)(char*, uint, void*);
417 int (*ftoa80)(char*, uint, void*);
420 int (*das)(Map*, ulong, char, char*, int); /* symbolic */
421 int (*kendas)(Map*, ulong, char, char*, int); /* symbolic */
422 int (*codas)(Map*, ulong, char, char*, int);
423 int (*hexinst)(Map*, ulong, char*, int); /* hex */
424 int (*instsize)(Map*, ulong); /* instruction size */
427 Mach *machbyname(char*);
428 Mach *machbytype(uint);
431 extern Mach machsparc;
432 extern Mach machmips;
433 extern Mach machpower;
436 * Debugging symbols and type information.
437 * (Not all objects include type information.)
444 /* symbol table classes */
446 CAUTO, /* stack variable */
447 CPARAM, /* function parameter */
448 CTEXT, /* text segment */
449 CDATA, /* data segment */
455 char *name; /* name of symbol */
456 /* Symtype *typedesc; /* type info, if any */
457 Loc loc; /* location of symbol */
458 Loc hiloc; /* location of end of symbol */
459 char class; /* CAUTO, ... */
460 char type; /* type letter from a.out.h */
461 Fhdr *fhdr; /* where did this come from? */
462 uint index; /* in by-address list */
464 /* private use by various symbol implementations */
481 /* look through all currently cracked Fhdrs calling their fns */
482 int pc2file(ulong pc, char *file, uint nfile, ulong *line);
483 int file2pc(char *file, ulong line, ulong *addr);
484 int line2pc(ulong basepc, ulong line, ulong *pc);
485 int fnbound(ulong pc, ulong *bounds);
486 int fileline(ulong pc, char *a, uint n);
487 int pc2line(ulong pc, ulong *line);
489 int lookupsym(char *fn, char *var, Symbol *s);
490 int indexsym(uint ndx, Symbol *s);
491 int findsym(Loc loc, uint class, Symbol *s);
492 int findexsym(Fhdr*, uint, Symbol*);
494 int lookuplsym(Symbol *s1, char *name, Symbol *s2);
495 int indexlsym(Symbol *s1, uint ndx, Symbol *s2);
496 int findlsym(Symbol *s1, Loc loc, Symbol *s);
497 int symoff(char *a, uint n, ulong addr, uint class);
498 int unwindframe(Map *map, Regs *regs, ulong *next, Symbol*);
502 extern Fhdr* fhdrlist;
503 Fhdr* findhdr(char*);
505 Symbol* flookupsym(Fhdr*, char*);
506 Symbol* ffindsym(Fhdr*, Loc, uint);
507 Symbol* _addsym(Fhdr*, Symbol*);
510 * Stack frame walking.
514 int stacktrace(Map*, Regs*, Tracer);
515 int windindex(char*);
516 Loc* windreglocs(void);
521 int localaddr(Map *map, Regs *regs, char *fn, char *var, ulong *val);
522 int fpformat(Map *map, Regdesc *reg, char *a, uint n, uint code);
523 char* _hexify(char*, ulong, int);
525 int loccmp(Loc*, Loc*);
526 int locsimplify(Map *map, Regs *regs, Loc loc, Loc *newloc);
527 Regdesc* regdesc(char*);
534 extern int machdebug;
535 #if defined(__cplusplus)