cirno/plan9port
1
0
Fork 0
mirror of https://github.com/9fans/plan9port.git synced 2025-01-12 11:10:07 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

libmach, acid, db: 64-bit support

Browse source
This commit is contained in:
Russ Cox 2012-02-19 18:11:39 -05:00
parent 60d96f2e43
commit 443d628838
36 changed files with 2311 additions and 1125 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

247
acid/amd64 Normal file
View file

@ -0,0 +1,247 @@
// 386 support
defn acidinit() // Called after all the init modules are loaded
{
bplist = {};
bpfmt = 'b';
srcpath = {
"./",
"/sys/src/libc/port/",
"/sys/src/libc/9sys/",
"/sys/src/libc/amd64/"
};
srcfiles = {}; // list of loaded files
srctext = {}; // the text of the files
}
defn linkreg(addr)
{
return {};
}
defn stk() // trace
{
_stk({"PC", *PC, "SP", *SP}, 0);
}
defn lstk() // trace with locals
{
_stk({"PC", *PC, "SP", *SP}, 1);
}
defn gpr() // print general(hah hah!) purpose registers
{
print("AX\t", *AX, " BX\t", *BX, " CX\t", *CX, " DX\t", *DX, "\n");
print("DI\t", *DI, " SI\t", *SI, " BP\t", *BP, "\n");
print("R8\t", *R8, " R9\t", *R9, " R10\t", *R10, " R11\t", *R11, "\n");
print("R12\t", *R12, " R13\t", *R13, " R14\t", *R14, " R15\t", *R15, "\n");
}
defn spr() // print special processor registers
{
local pc;
local cause;
pc = *PC;
print("PC\t", pc, " ", fmt(pc, 'a'), " ");
pfl(pc);
print("SP\t", *SP, " FLAGS ", *FLAGS, "\n");
print("CS\t", *CS, " DS\t ", *DS, " SS\t", *SS, "\n");
print("GS\t", *GS, " FS\t ", *FS, " ES\t", *ES, "\n");
cause = *TRAP;
print("TRAP\t", cause, " ", reason(cause), "\n");
}
defn regs() // print all registers
{
spr();
gpr();
}
defn mmregs()
{
print("MM0\t", *MM0, " MM1\t", *MM1, "\n");
print("MM2\t", *MM2, " MM3\t", *MM3, "\n");
print("MM4\t", *MM4, " MM5\t", *MM5, "\n");
print("MM6\t", *MM6, " MM7\t", *MM7, "\n");
}
defn pfixstop(pid)
{
if *fmt(*PC-1, 'b') == 0xCC then {
// Linux stops us after the breakpoint, not at it
*PC = *PC-1;
}
}
defn pstop(pid)
{
local l;
local pc;
local why;
pc = *PC;
// FIgure out why we stopped.
if *fmt(pc, 'b') == 0xCC then {
why = "breakpoint";
// fix up instruction for print; will put back later
*pc = @pc;
} else if *(pc-2\x) == 0x80CD then {
pc = pc-2;
why = "system call";
} else
why = "stopped";
if printstopped then {
print(pid,": ", why, "\t");
print(fmt(pc, 'a'), "\t", *fmt(pc, 'i'), "\n");
}
if why == "breakpoint" then
*fmt(pc, bpfmt) = bpinst;
if printstopped && notes then {
if notes[0] != "sys: breakpoint" then {
print("Notes pending:\n");
l = notes;
while l do {
print("\t", head l, "\n");
l = tail l;
}
}
}
}
aggr Ureg
{
'Y' 0 ax;
'Y' 8 bx;
'Y' 16 cx;
'Y' 24 dx;
'Y' 32 si;
'Y' 40 di;
'Y' 48 bp;
'Y' 56 r8;
'Y' 64 r9;
'Y' 72 r10;
'Y' 80 r11;
'Y' 88 r12;
'Y' 96 r13;
'Y' 104 r14;
'Y' 112 r15;
'u' 120 ds;
'u' 122 es;
'u' 124 fs;
'u' 126 gs;
'Y' 128 type;
'Y' 136 error;
'Y' 144 pc;
'Y' 152 cs;
'Y' 160 flags;
'Y' 168 sp;
'Y' 176 ss;
};
defn
Ureg(addr) {
complex Ureg addr;
print(" ax ", addr.ax, "\n");
print(" bx ", addr.bx, "\n");
print(" cx ", addr.cx, "\n");
print(" dx ", addr.dx, "\n");
print(" si ", addr.si, "\n");
print(" di ", addr.di, "\n");
print(" bp ", addr.bp, "\n");
print(" r8 ", addr.r8, "\n");
print(" r9 ", addr.r9, "\n");
print(" r10 ", addr.r10, "\n");
print(" r11 ", addr.r11, "\n");
print(" r12 ", addr.r12, "\n");
print(" r13 ", addr.r13, "\n");
print(" r14 ", addr.r14, "\n");
print(" r15 ", addr.r15, "\n");
print(" ds ", addr.ds, "\n");
print(" es ", addr.es, "\n");
print(" fs ", addr.fs, "\n");
print(" gs ", addr.gs, "\n");
print(" type ", addr.type, "\n");
print(" error ", addr.error, "\n");
print(" pc ", addr.pc, "\n");
print(" cs ", addr.cs, "\n");
print(" flags ", addr.flags, "\n");
print(" sp ", addr.sp, "\n");
print(" ss ", addr.ss, "\n");
};
sizeofUreg = 184;
// aggr Linkdebug
// {
// 'X' 0 version;
// 'X' 4 map;
// };
//
// aggr Linkmap
// {
// 'X' 0 addr;
// 'X' 4 name;
// 'X' 8 dynsect;
// 'X' 12 next;
// 'X' 16 prev;
// };
//
// defn
// linkdebug()
// {
// local a;
//
// if !havesymbol("_DYNAMIC") then
// return 0;
//
// a = _DYNAMIC;
// while *a != 0 do {
// if *a == 21 then // 21 == DT_DEBUG
// return *(a+4);
// a = a+8;
// }
// return 0;
// }
//
// defn
// dynamicmap()
// {
// if systype == "linux" || systype == "freebsd" then {
// local r, m, n;
//
// r = linkdebug();
// if r then {
// complex Linkdebug r;
// m = r.map;
// n = 0;
// while m != 0 && n < 100 do {
// complex Linkmap m;
// if m.name && *(m.name\b) && access(*(m.name\s)) then
// print("textfile({\"", *(m.name\s), "\", ", m.addr\X, "});\n");
// m = m.next;
// n = n+1;
// }
// }
// }
// }
// */
defn
acidmap()
{
// dynamicmap();
acidtypes();
}
print(acidfile);

131
include/mach.h
View file

@ -11,10 +11,9 @@ AUTOLIB(mach)
/*
* Architecture-dependent application data.
*
* The code assumes that ulong is big enough to hold
* The code assumes that u64int 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.
* register.
*
* Supported architectures:
*
@ -39,7 +38,7 @@ typedef struct Seg Seg;
typedef struct Symbol Symbol;
typedef struct Symtype Symtype;
typedef int (*Tracer)(Map*, Regs*, ulong, ulong, Symbol*, int);
typedef int (*Tracer)(Map*, Regs*, u64int, u64int, Symbol*, int);
extern Mach *mach;
extern Mach *machcpu;
@ -84,10 +83,10 @@ struct Seg
uchar *p;
int fd;
int pid;
ulong base;
ulong size;
ulong offset;
int (*rw)(Map*, Seg*, ulong, void*, uint, int);
u64int base;
u64int size;
u64int offset;
int (*rw)(Map*, Seg*, u64int, void*, uint, int);
};
struct Map
@ -98,7 +97,7 @@ struct Map
struct Regs
{
int (*rw)(Regs*, char*, ulong*, int);
int (*rw)(Regs*, char*, u64int*, int);
};
typedef struct UregRegs UregRegs;
@ -107,7 +106,7 @@ struct UregRegs
Regs r;
uchar *ureg;
};
int _uregrw(Regs*, char*, ulong*, int);
int _uregrw(Regs*, char*, u64int*, int);
typedef struct PidRegs PidRegs;
struct PidRegs
@ -119,23 +118,24 @@ struct PidRegs
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);
int addrtoseg(Map *map, u64int addr, Seg *seg);
int addrtosegafter(Map *map, u64int 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 get1(Map *map, u64int addr, uchar *a, uint n);
int get2(Map *map, u64int addr, u16int *u);
int get4(Map *map, u64int addr, u32int *u);
int get8(Map *map, u64int addr, u64int *u);
int geta(Map *map, u64int 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 put1(Map *map, u64int addr, uchar *a, uint n);
int put2(Map *map, u64int addr, u16int u);
int put4(Map *map, u64int addr, u32int u);
int put8(Map *map, u64int addr, u64int u);
int rget(Regs*, char*, ulong*);
int rput(Regs*, char*, ulong);
int rget(Regs*, char*, u64int*);
int rput(Regs*, char*, u64int);
/*
* A location is either a memory address or a register.
@ -163,7 +163,7 @@ struct Loc
{
uint type; /* LNONE, ... */
char *reg; /* LREG */
ulong addr; /* LADDR, CONST */
u64int addr; /* LADDR, CONST */
long offset; /* LOFFSET */
};
@ -171,6 +171,7 @@ 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 lgeta(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);
@ -178,8 +179,8 @@ 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 locaddr(u64int addr);
Loc locconst(u64int con);
Loc locreg(char*);
Loc locindir(char*, long);
@ -242,20 +243,20 @@ struct Fhdr
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 */
u64int txtaddr; /* text address */
u64int entry; /* entry point */
u64int txtsz; /* text size */
u64int txtoff; /* text offset in file */
u64int dataddr; /* data address */
u64int datsz; /* data size */
u64int datoff; /* data offset in file */
u64int bsssz; /* bss size */
u64int symsz; /* symbol table size */
u64int symoff; /* symbol table offset in file */
u64int sppcsz; /* size of sp-pc table */
u64int sppcoff; /* offset of sp-pc table in file */
u64int lnpcsz; /* size of line number-pc table */
u64int 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 */
@ -280,21 +281,21 @@ struct Fhdr
Fhdr *next; /* link to next fhdr (internal) */
/* file mapping */
int (*map)(Fhdr*, ulong, Map*, Regs**);
int (*map)(Fhdr*, u64int, 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 (*pc2file)(Fhdr*, u64int, char*, uint, ulong*);
int (*file2pc)(Fhdr*, char*, u64int, u64int*);
int (*line2pc)(Fhdr*, u64int, ulong, u64int*);
int (*lookuplsym)(Fhdr*, Symbol*, char*, Symbol*);
int (*indexlsym)(Fhdr*, Symbol*, uint, Symbol*);
int (*findlsym)(Fhdr*, Symbol*, Loc, Symbol*);
int (*unwind)(Fhdr*, Map*, Regs*, ulong*, Symbol*);
int (*unwind)(Fhdr*, Map*, Regs*, u64int*, Symbol*);
};
Fhdr* crackhdr(char *file, int mode);
@ -310,7 +311,7 @@ int symstabs(Fhdr*);
int symmacho(Fhdr*);
void symclose(Fhdr*);
int mapfile(Fhdr *fp, ulong base, Map *map, Regs **regs);
int mapfile(Fhdr *fp, u64int base, Map *map, Regs **regs);
void unmapfile(Fhdr *fp, Map *map);
/*
@ -385,6 +386,7 @@ enum
MARM, /* ARM */
MPOWER, /* PowerPC */
MALPHA, /* DEC/Compaq Alpha */
MAMD64, /* AMD64 */
NMTYPE
};
@ -402,8 +404,8 @@ struct Mach
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 */
u64int kbase; /* kernel base address for Plan 9 */
u64int ktmask; /* ktzero = kbase & ~ktmask */
uint pcquant; /* pc quantum */
uint szaddr; /* size of pointer in bytes */
uint szreg; /* size of integer register */
@ -415,9 +417,9 @@ struct Mach
uchar bpinst[4]; /* break point instruction */
uint bpsize; /* size of bp instruction */
int (*foll)(Map*, Regs*, ulong, ulong*); /* follow set */
int (*foll)(Map*, Regs*, u64int, u64int*); /* follow set */
char* (*exc)(Map*, Regs*); /* last exception */
int (*unwind)(Map*, Regs*, ulong*, Symbol*);
int (*unwind)(Map*, Regs*, u64int*, Symbol*);
/* cvt to local byte order */
u16int (*swap2)(u16int);
@ -428,11 +430,11 @@ struct Mach
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 */
int (*das)(Map*, u64int, char, char*, int); /* symbolic */
int (*kendas)(Map*, u64int, char, char*, int); /* symbolic */
int (*codas)(Map*, u64int, char, char*, int);
int (*hexinst)(Map*, u64int, char*, int); /* hex */
int (*instsize)(Map*, u64int); /* instruction size */
};
Mach *machbyname(char*);
@ -442,6 +444,7 @@ extern Mach mach386;
extern Mach machsparc;
extern Mach machmips;
extern Mach machpower;
extern Mach machamd64;
/*
* Debugging symbols and type information.
@ -494,12 +497,12 @@ struct Symbol
};
/* 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 pc2file(u64int pc, char *file, uint nfile, ulong *line);
int file2pc(char *file, ulong line, u64int *addr);
int line2pc(u64int basepc, ulong line, u64int *pc);
int fnbound(u64int pc, u64int *bounds);
int fileline(u64int pc, char *a, uint n);
int pc2line(u64int pc, ulong *line);
int lookupsym(char *fn, char *var, Symbol *s);
int indexsym(uint ndx, Symbol *s);
@ -509,8 +512,8 @@ 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, Symbol*);
int symoff(char *a, uint n, u64int addr, uint class);
int unwindframe(Map *map, Regs *regs, u64int *next, Symbol*);
void _addhdr(Fhdr*);
void _delhdr(Fhdr*);
@ -536,9 +539,9 @@ Loc* windreglocs(void);
/*
* Debugger help.
*/
int localaddr(Map *map, Regs *regs, char *fn, char *var, ulong *val);
int localaddr(Map *map, Regs *regs, char *fn, char *var, u64int *val);
int fpformat(Map *map, Regdesc *reg, char *a, uint n, uint code);
char* _hexify(char*, ulong, int);
char* _hexify(char*, u64int, int);
int locfmt(Fmt*);
int loccmp(Loc*, Loc*);
int locsimplify(Map *map, Regs *regs, Loc loc, Loc *newloc);

8
include/u.h
View file

@ -146,16 +146,16 @@ typedef signed char schar;
typedef unsigned long long uvlong;
typedef long long vlong;
typedef uint64_t u64int;
typedef int64_t s64int;
typedef uvlong u64int;
typedef vlong s64int;
typedef uint8_t u8int;
typedef int8_t s8int;
typedef uint16_t u16int;
typedef int16_t s16int;
typedef uintptr_t uintptr;
typedef intptr_t intptr;
typedef uint32_t u32int;
typedef int32_t s32int;
typedef uint u32int;
typedef int s32int;
typedef u32int uint32;
typedef s32int int32;

4
src/cmd/acid/acid.h
View file

@ -192,7 +192,7 @@ struct String
int len;
};
int acidregsrw(Regs*, char*, ulong*, int);
int acidregsrw(Regs*, char*, u64int*, int);
List* addlist(List*, List*);
void addvarsym(Fhdr*);
List* al(int);
@ -263,7 +263,7 @@ String* strnode(char*);
String* strnodlen(char*, int);
#define system acidsystem
char* system(void);
int trlist(Map*, Regs*, ulong, ulong, Symbol*, int);
int trlist(Map*, Regs*, u64int, u64int, Symbol*, int);
void unwind(void);
void userinit(void);
void varreg(void);

8
src/cmd/acid/builtin.c
View file

@ -453,7 +453,7 @@ follow(Node *r, Node *args)
{
int n, i;
Node res;
ulong f[10];
u64int f[10];
List **tail, *l;
if(args == 0)
@ -480,7 +480,7 @@ funcbound(Node *r, Node *args)
{
int n;
Node res;
ulong bounds[2];
u64int bounds[2];
List *l;
if(args == 0)
@ -523,7 +523,7 @@ filepc(Node *r, Node *args)
int i;
Node res;
char *p, c;
ulong v;
u64int v;
if(args == 0)
error("filepc(filename:line): arg count");
@ -1035,7 +1035,7 @@ static struct
static int nsregs;
static int
straceregrw(Regs *regs, char *name, ulong *val, int isr)
straceregrw(Regs *regs, char *name, u64int *val, int isr)
{
int i;

2
src/cmd/acid/exec.c
View file

@ -354,7 +354,7 @@ indir(Map *m, ulong addr, char fmt, Node *r)
void
indirreg(Regs *regs, char *name, char fmt, Node *r)
{
ulong val;
u64int val;
if(regs == 0)
error("no register set for *%s=", name);

6
src/cmd/acid/expr.c
View file

@ -168,7 +168,7 @@ oframe(Node *n, Node *res)
{
char *p;
Node *lp;
ulong ival;
u64int ival;
Frtype *f;
p = n->sym->name;
@ -1070,12 +1070,12 @@ initexpr(void)
}
int
acidregsrw(Regs *r, char *name, ulong *u, int isr)
acidregsrw(Regs *r, char *name, u64int *u, int isr)
{
Lsym *l;
Value *v;
Node *n;
ulong addr;
u64int addr;
u32int u32;
if(!isr){

4
src/cmd/acid/list.c
View file

@ -196,7 +196,7 @@ listregisters(Map *map, Regs *regs)
{
List **tail, *l2, *l;
Regdesc *rp;
ulong v;
u64int v;
l2 = 0;
tail = &l2;
@ -255,7 +255,7 @@ listautos(Map *map, Regs *regs, Symbol *fn)
}
int
trlist(Map *map, Regs *regs, ulong pc, ulong callerpc, Symbol *sym, int depth)
trlist(Map *map, Regs *regs, u64int pc, u64int callerpc, Symbol *sym, int depth)
{
List *q, *l;
static List **tail;

3
src/cmd/acid/main.c
View file

@ -93,6 +93,8 @@ main(int argc, char *argv[])
usage();
}ARGEND
USED(pid);
fmtinstall('Z', Zfmt);
fmtinstall('L', locfmt);
Binit(&bioout, 1, OWRITE);
@ -195,6 +197,7 @@ attachfiles(int argc, char **argv)
pid = 0;
interactive = 0;
USED(pid);
if(setjmp(err))
return -1;

2
src/cmd/db/defs.h
View file

@ -11,7 +11,7 @@
#include <mach.h>
typedef long WORD;
typedef ulong ADDR;
typedef u64int ADDR;
#define HUGEINT 0x7fffffff /* enormous WORD */

4
src/cmd/db/expr.c
View file

@ -166,7 +166,7 @@ item(int a)
{ /* name [ . local ] | number | . | ^ | <register | 'x | | */
char *base;
char savc;
ulong u;
u64int u;
Symbol s;
char gsym[MAXSYM], lsym[MAXSYM];
@ -388,7 +388,7 @@ dbround(long a, long b)
ulong
dbrget(Map *map, char *name)
{
ulong u;
u64int u;
USED(map);
if(rget(correg, name, &u) < 0)

7
src/cmd/db/print.c
View file

@ -22,7 +22,7 @@ static void printfp(Map*, int);
* callback on stack trace
*/
static int
ptrace(Map *map, Regs *regs, ulong pc, ulong nextpc, Symbol *sym, int depth)
ptrace(Map *map, Regs *regs, u64int pc, u64int nextpc, Symbol *sym, int depth)
{
char buf[512];
@ -48,7 +48,7 @@ ptrace(Map *map, Regs *regs, ulong pc, ulong nextpc, Symbol *sym, int depth)
static ulong *adrregvals;
static int
adrrw(Regs *regs, char *name, ulong *val, int isr)
adrrw(Regs *regs, char *name, u64int *val, int isr)
{
int i;
@ -215,6 +215,7 @@ printdollar(int modif)
default:
error("bad `$' command");
}
USED(r);
}
@ -359,7 +360,7 @@ void
printpc(void)
{
char buf[512];
ulong u;
u64int u;
if(rget(correg, mach->pc, &u) < 0)
error("%r");

2
src/cmd/db/regs.c
View file

@ -13,7 +13,7 @@ printregs(int c)
{
Regdesc *rp;
int i;
ulong u;
ADDR u;
if(correg == nil){
dprint("registers not mapped\n");

2
src/cmd/db/trcrun.c
View file

@ -208,7 +208,7 @@ void
runstep(ulong loc, int keepnote)
{
int nfoll;
ulong foll[3];
ADDR foll[3];
BKPT bkpt[3];
int i;

8
src/libmach/Linux.c
View file

@ -36,8 +36,8 @@ struct PtraceRegs
int pid;
};
static int ptracesegrw(Map*, Seg*, ulong, void*, uint, int);
static int ptraceregrw(Regs*, char*, ulong*, int);
static int ptracesegrw(Map*, Seg*, u64int, void*, uint, int);
static int ptraceregrw(Regs*, char*, u64int*, int);
static int attachedpids[1000];
static int nattached;
@ -173,7 +173,7 @@ ptraceerr:
}
static int
ptracesegrw(Map *map, Seg *seg, ulong addr, void *v, uint n, int isr)
ptracesegrw(Map *map, Seg *seg, u64int addr, void *v, uint n, int isr)
{
addr += seg->base;
return ptracerw(isr ? PTRACE_PEEKDATA : PTRACE_POKEDATA, PTRACE_PEEKDATA,
@ -212,7 +212,7 @@ reg2linux(char *reg)
}
static int
ptraceregrw(Regs *regs, char *name, ulong *val, int isr)
ptraceregrw(Regs *regs, char *name, u64int *val, int isr)
{
int pid;
ulong addr;

2
src/libmach/crack.c
View file

@ -93,7 +93,7 @@ uncrackhdr(Fhdr *hdr)
}
int
mapfile(Fhdr *fp, ulong base, Map *map, Regs **regs)
mapfile(Fhdr *fp, u64int base, Map *map, Regs **regs)
{
if(fp == nil){
werrstr("no file");

12
src/libmach/crackelf.c
View file

@ -4,7 +4,7 @@
#include "elf.h"
#include "dwarf.h"
static int mapelf(Fhdr *fp, ulong base, Map *map, Regs**);
static int mapelf(Fhdr *fp, u64int base, Map *map, Regs**);
static int unpacknote(Elf *elf, uchar *a, uchar *ea, ElfNote *note, uchar **pa);
static struct
@ -21,6 +21,7 @@ static struct
ElfMachArm, MARM, nil, "arm",
ElfMachPower, MPOWER, nil, "powerpc",
ElfMachPower64, MNONE, nil, "powerpc64",
ElfMachAmd64, MAMD64, &machamd64, "amd64",
};
static struct
@ -44,7 +45,8 @@ static struct
{ /* Font Tab 4 */
M386, ALINUX, elfcorelinux386,
M386, ANONE, elfcorelinux386, /* [sic] */
/* M386, AFREEBSD, elfcorefreebsd386, */
// M386, AFREEBSD, elfcorefreebsd386,
MAMD64, AFREEBSD, elfcorefreebsdamd64,
};
int
@ -202,13 +204,13 @@ err:
}
static int
mapelf(Fhdr *fp, ulong base, Map *map, Regs **regs)
mapelf(Fhdr *fp, u64int base, Map *map, Regs **regs)
{
int i;
Elf *elf;
ElfProg *p;
ulong sz;
ulong lim;
u64int sz;
u64int lim;
Seg s;
elf = fp->elf;

4
src/libmach/crackmacho.c
View file

@ -3,7 +3,7 @@
#include <mach.h>
#include "macho.h"
static int mapmacho(Fhdr *fp, ulong base, Map *map, Regs**);
static int mapmacho(Fhdr *fp, u64int base, Map *map, Regs**);
static struct
{
@ -136,7 +136,7 @@ err:
}
static int
mapmacho(Fhdr *fp, ulong base, Map *map, Regs **rp)
mapmacho(Fhdr *fp, u64int base, Map *map, Regs **rp)
{
int i, n;
uchar *u;

183
src/libmach/elf.c
View file

@ -13,6 +13,11 @@ typedef struct ElfSectBytes ElfSectBytes;
typedef struct ElfProgBytes ElfProgBytes;
typedef struct ElfSymBytes ElfSymBytes;
typedef struct ElfHdrBytes64 ElfHdrBytes64;
typedef struct ElfSectBytes64 ElfSectBytes64;
typedef struct ElfProgBytes64 ElfProgBytes64;
typedef struct ElfSymBytes64 ElfSymBytes64;
struct ElfHdrBytes
{
uchar ident[16];
@ -31,6 +36,24 @@ struct ElfHdrBytes
uchar shstrndx[2];
};
struct ElfHdrBytes64
{
uchar ident[16];
uchar type[2];
uchar machine[2];
uchar version[4];
uchar entry[8];
uchar phoff[8];
uchar shoff[8];
uchar flags[4];
uchar ehsize[2];
uchar phentsize[2];
uchar phnum[2];
uchar shentsize[2];
uchar shnum[2];
uchar shstrndx[2];
};
struct ElfSectBytes
{
uchar name[4];
@ -45,6 +68,20 @@ struct ElfSectBytes
uchar entsize[4];
};
struct ElfSectBytes64
{
uchar name[4];
uchar type[4];
uchar flags[8];
uchar addr[8];
uchar offset[8];
uchar size[8];
uchar link[4];
uchar info[4];
uchar align[8];
uchar entsize[8];
};
struct ElfSymBytes
{
uchar name[4];
@ -55,6 +92,16 @@ struct ElfSymBytes
uchar shndx[2];
};
struct ElfSymBytes64
{
uchar name[4];
uchar info;
uchar other;
uchar shndx[2];
uchar value[8];
uchar size[8];
};
struct ElfProgBytes
{
uchar type[4];
@ -67,11 +114,23 @@ struct ElfProgBytes
uchar align[4];
};
struct ElfProgBytes64
{
uchar type[4];
uchar flags[4];
uchar offset[8];
uchar vaddr[8];
uchar paddr[8];
uchar filesz[8];
uchar memsz[8];
uchar align[8];
};
uchar ElfMagic[4] = { 0x7F, 'E', 'L', 'F' };
static void unpackhdr(ElfHdr*, ElfHdrBytes*);
static void unpackprog(ElfHdr*, ElfProg*, ElfProgBytes*);
static void unpacksect(ElfHdr*, ElfSect*, ElfSectBytes*);
static void unpackhdr(ElfHdr*, void*);
static void unpackprog(ElfHdr*, ElfProg*, void*);
static void unpacksect(ElfHdr*, ElfSect*, void*);
static char *elftypes[] = {
"none",
@ -128,9 +187,11 @@ elfinit(int fd)
int i;
Elf *e;
ElfHdr *h;
ElfHdrBytes hdrb;
ElfProgBytes progb;
ElfSectBytes sectb;
union {
ElfHdrBytes h32;
ElfHdrBytes64 h64;
} hdrb;
void *p;
ElfSect *s;
e = mallocz(sizeof(Elf), 1);
@ -146,17 +207,17 @@ elfinit(int fd)
goto err;
h = &e->hdr;
unpackhdr(h, &hdrb);
if(h->class != ElfClass32){
werrstr("bad ELF class - not 32-bit");
if(h->class != ElfClass32 && h->class != ElfClass64){
werrstr("bad ELF class - not 32-bit, 64-bit");
goto err;
}
if(h->encoding != ElfDataLsb && h->encoding != ElfDataMsb){
werrstr("bad ELF encoding - not LSB, MSB");
goto err;
}
if(hdrb.ident[6] != h->version){
if(hdrb.h32.ident[6] != h->version){
werrstr("bad ELF encoding - version mismatch %02ux and %08ux",
(uint)hdrb.ident[6], (uint)h->version);
(uint)hdrb.h32.ident[6], (uint)h->version);
goto err;
}
@ -165,23 +226,27 @@ elfinit(int fd)
*/
e->nprog = h->phnum;
e->prog = mallocz(sizeof(ElfProg)*e->nprog, 1);
p = mallocz(h->phentsize, 1);
for(i=0; i<e->nprog; i++){
if(seek(fd, h->phoff+i*h->phentsize, 0) < 0
|| readn(fd, &progb, sizeof progb) != sizeof progb)
|| readn(fd, p, h->phentsize) != h->phentsize)
goto err;
unpackprog(h, &e->prog[i], &progb);
unpackprog(h, &e->prog[i], p);
}
free(p);
e->nsect = h->shnum;
if(e->nsect == 0)
goto nosects;
e->sect = mallocz(sizeof(ElfSect)*e->nsect, 1);
p = mallocz(h->shentsize, 1);
for(i=0; i<e->nsect; i++){
if(seek(fd, h->shoff+i*h->shentsize, 0) < 0
|| readn(fd, &sectb, sizeof sectb) != sizeof sectb)
|| readn(fd, p, h->shentsize) != h->shentsize)
goto err;
unpacksect(h, &e->sect[i], &sectb);
unpacksect(h, &e->sect[i], p);
}
free(p);
if(h->shstrndx >= e->nsect){
fprint(2, "warning: bad string section index %d >= %d", h->shstrndx, e->nsect);
@ -243,12 +308,15 @@ elfclose(Elf *elf)
}
static void
unpackhdr(ElfHdr *h, ElfHdrBytes *b)
unpackhdr(ElfHdr *h, void *v)
{
u16int (*e2)(uchar*);
u32int (*e4)(uchar*);
u64int (*e8)(uchar*);
ElfHdrBytes *b;
ElfHdrBytes64 *b64;
b = v;
memmove(h->magic, b->ident, 4);
h->class = b->ident[4];
h->encoding = b->ident[5];
@ -273,6 +341,9 @@ unpackhdr(ElfHdr *h, ElfHdrBytes *b)
h->e4 = e4;
h->e8 = e8;
if(h->class == ElfClass64)
goto b64;
h->type = e2(b->type);
h->machine = e2(b->machine);
h->version = e4(b->version);
@ -286,13 +357,36 @@ unpackhdr(ElfHdr *h, ElfHdrBytes *b)
h->shentsize = e2(b->shentsize);
h->shnum = e2(b->shnum);
h->shstrndx = e2(b->shstrndx);
return;
b64:
b64 = v;
h->type = e2(b64->type);
h->machine = e2(b64->machine);
h->version = e4(b64->version);
h->entry = e8(b64->entry);
h->phoff = e8(b64->phoff);
h->shoff = e8(b64->shoff);
h->flags = e4(b64->flags);
h->ehsize = e2(b64->ehsize);
h->phentsize = e2(b64->phentsize);
h->phnum = e2(b64->phnum);
h->shentsize = e2(b64->shentsize);
h->shnum = e2(b64->shnum);
h->shstrndx = e2(b64->shstrndx);
return;
}
static void
unpackprog(ElfHdr *h, ElfProg *p, ElfProgBytes *b)
unpackprog(ElfHdr *h, ElfProg *p, void *v)
{
u32int (*e4)(uchar*);
u64int (*e8)(uchar*);
if(h->class == ElfClass32) {
ElfProgBytes *b;
b = v;
e4 = h->e4;
p->type = e4(b->type);
p->offset = e4(b->offset);
@ -302,13 +396,33 @@ unpackprog(ElfHdr *h, ElfProg *p, ElfProgBytes *b)
p->memsz = e4(b->memsz);
p->flags = e4(b->flags);
p->align = e4(b->align);
} else {
ElfProgBytes64 *b;
b = v;
e4 = h->e4;
e8 = h->e8;
p->type = e4(b->type);
p->offset = e8(b->offset);
p->vaddr = e8(b->vaddr);
p->paddr = e8(b->paddr);
p->filesz = e8(b->filesz);
p->memsz = e8(b->memsz);
p->flags = e4(b->flags);
p->align = e8(b->align);
}
}
static void
unpacksect(ElfHdr *h, ElfSect *s, ElfSectBytes *b)
unpacksect(ElfHdr *h, ElfSect *s, void *v)
{
u32int (*e4)(uchar*);
u64int (*e8)(uchar*);
if(h->class == ElfClass32) {
ElfSectBytes *b;
b = v;
e4 = h->e4;
s->name = (char*)(uintptr)e4(b->name);
s->type = e4(b->type);
@ -320,6 +434,23 @@ unpacksect(ElfHdr *h, ElfSect *s, ElfSectBytes *b)
s->info = e4(b->info);
s->align = e4(b->align);
s->entsize = e4(b->entsize);
} else {
ElfSectBytes64 *b;
b = v;
e4 = h->e4;
e8 = h->e8;
s->name = (char*)(uintptr)e4(b->name);
s->type = e4(b->type);
s->flags = e8(b->flags);
s->addr = e8(b->addr);
s->offset = e8(b->offset);
s->size = e8(b->size);
s->link = e4(b->link);
s->info = e4(b->info);
s->align = e8(b->align);
s->entsize = e8(b->entsize);
}
}
ElfSect*
@ -374,6 +505,7 @@ elfsym(Elf *elf, int i, ElfSym *sym)
extract:
if(elfmap(elf, symtab) < 0 || elfmap(elf, strtab) < 0)
return -1;
if(elf->hdr.class == ElfClass32) {
p = symtab->base + i * sizeof(ElfSymBytes);
s = (char*)strtab->base;
x = elf->hdr.e4(p);
@ -389,6 +521,23 @@ elfsym(Elf *elf, int i, ElfSym *sym)
sym->type = x & 0xF;
sym->other = p[13];
sym->shndx = elf->hdr.e2(p+14);
} else {
p = symtab->base + i * sizeof(ElfSymBytes64);
s = (char*)strtab->base;
x = elf->hdr.e4(p);
if(x >= strtab->size){
werrstr("bad symbol name offset 0x%lux", x);
return -1;
}
sym->name = s + x;
x = p[4];
sym->bind = x>>4;
sym->type = x & 0xF;
sym->other = p[5];
sym->shndx = elf->hdr.e2(p+6);
sym->value = elf->hdr.e8(p+8);
sym->size = elf->hdr.e8(p+16);
}
return 0;
}
i -= elf->nsymtab;

37
src/libmach/elf.h
View file

@ -54,6 +54,7 @@ enum
ElfMachAlpha, /* Digital Alpha */
ElfMachSH, /* Hitachi SH */
ElfMachSparc9, /* SPARC V9 */
ElfMachAmd64 = 62, /* x86-64 */
/* and the list goes on... */
ElfAbiNone = 0,
@ -138,9 +139,9 @@ struct ElfHdr
uchar abiversion;
u32int type;
u32int machine;
u32int entry;
u32int phoff;
u32int shoff;
u64int entry;
u64int phoff;
u64int shoff;
u32int flags;
u32int ehsize;
u32int phentsize;
@ -157,27 +158,27 @@ struct ElfSect
{
char *name;
u32int type;
u32int flags;
u32int addr;
u32int offset;
u32int size;
u64int flags;
u64int addr;
u64int offset;
u64int size;
u32int link;
u32int info;
u32int align;
u32int entsize;
u64int align;
u64int entsize;
uchar *base;
};
struct ElfProg
{
u32int type;
u32int offset;
u32int vaddr;
u32int paddr;
u32int filesz;
u32int memsz;
u64int offset;
u64int vaddr;
u64int paddr;
u64int filesz;
u64int memsz;
u32int flags;
u32int align;
u64int align;
};
struct ElfNote
@ -193,8 +194,8 @@ struct ElfNote
struct ElfSym
{
char* name;
u32int value;
u32int size;
u64int value;
u64int size;
uchar bind;
uchar type;
uchar other;
@ -234,4 +235,6 @@ int elfmap(Elf*, ElfSect*);
struct Fhdr;
void elfcorelinux386(struct Fhdr*, Elf*, ElfNote*);
void elfcorefreebsd386(struct Fhdr*, Elf*, ElfNote*);
void elfcorefreebsdamd64(struct Fhdr*, Elf*, ElfNote*);
void elfdl386mapdl(int);

150
src/libmach/elfcorefreebsdamd64.c Normal file
View file

@ -0,0 +1,150 @@
#include <u.h>
#include <libc.h>
#include <mach.h>
#include "elf.h"
#include "uregamd64.h"
typedef struct Ureg Ureg;
// See FreeBSD's sys/procfs.h.
typedef struct Lreg Lreg;
typedef struct Status Status;
typedef struct Psinfo Psinfo;
struct Lreg
{
u64int r15;
u64int r14;
u64int r13;
u64int r12;
u64int r11;
u64int r10;
u64int r9;
u64int r8;
u64int rdi;
u64int rsi;
u64int rbp;
u64int rbx;
u64int rdx;
u64int rcx;
u64int rax;
u32int trapno;
u16int fs;
u16int gs;
u32int err;
u16int es;
u16int ds;
u64int rip;
u64int cs;
u64int rflags;
u64int rsp;
u64int ss;
};
struct Status
{
u32int version; /* Version number of struct (1) */
u64int statussz; /* sizeof(prstatus_t) (1) */
u64int gregsetsz; /* sizeof(gregset_t) (1) */
u64int fpregsetsz; /* sizeof(fpregset_t) (1) */
u32int osreldate; /* Kernel version (1) */
u32int cursig; /* Current signal (1) */
u32int pid; /* Process ID (1) */
Lreg reg; /* General purpose registers (1) */
};
struct Psinfo
{
u32int version;
u64int size;
char name[17];
char psargs[81];
};
void
elfcorefreebsdamd64(Fhdr *fp, Elf *elf, ElfNote *note)
{
Status *s;
Lreg *l;
Ureg *u;
int i;
switch(note->type) {
case ElfNotePrStatus:
if(note->descsz < sizeof(Status)){
fprint(2, "warning: elf status note too small\n");
break;
}
s = (Status*)note->desc;
if(s->version != 1){
fprint(2, "warning: unknown elf note status version %ud\n", (uint)s->version);
break;
}
l = &s->reg;
u = malloc(sizeof(Ureg));
/* no byte order problems - just copying and rearranging */
u->ax = l->rax;
u->bx = l->rbx;
u->cx = l->rcx;
u->dx = l->rdx;
u->si = l->rsi;
u->di = l->rdi;
u->bp = l->rbp;
u->r8 = l->r8;
u->r9 = l->r9;
u->r10 = l->r10;
u->r11 = l->r11;
u->r12 = l->r12;
u->r13 = l->r13;
u->r14 = l->r14;
u->r15 = l->r15;
u->ds = l->ds;
u->es = l->es;
u->fs = l->fs;
u->gs = l->gs;
u->type = l->trapno;
u->error = l->err;
u->ip = l->rip;
u->cs = l->cs;
u->flags = l->rflags;
u->sp = l->rsp;
u->ss = l->ss;
if((fp->thread = realloc(fp->thread, (1+fp->nthread)*sizeof(fp->thread[0]))) == nil){
fprint(2, "warning: out of memory saving thread info\n");
return;
}
i = fp->nthread;
fp->thread[i].id = s->pid;
fp->thread[i].ureg = u;
fp->nthread++;
break;
}
}
int
corecmdfreebsd386(Elf *elf, ElfNote *note, char **pp)
{
char *t;
Psinfo *p;
*pp = nil;
if(note->descsz < sizeof(Psinfo)){
werrstr("elf psinfo note too small");
return -1;
}
p = (Psinfo*)note->desc;
/* print("elf name %s\nelf args %s\n", p->name, p->psargs); */
t = malloc(80+1);
if(t == nil)
return -1;
memmove(t, p->psargs, 80);
t[80] = 0;
*pp = t;
return 0;
}

8
src/libmach/frame.c
View file

@ -9,11 +9,11 @@ struct LocRegs
Regs r;
Regs *oldregs;
Map *map;
ulong *val;
u64int *val;
};
static int
locregrw(Regs *regs, char *name, ulong *val, int isr)
locregrw(Regs *regs, char *name, u64int *val, int isr)
{
int i;
LocRegs *lr;
@ -36,8 +36,8 @@ stacktrace(Map *map, Regs *regs, Tracer trace)
{
char *rname;
int i, ipc, ret;
ulong nextpc, pc, v;
ulong *cur, *next;
u64int nextpc, pc, v;
u64int *cur, *next;
LocRegs lr;
Symbol s, *sp;

2
src/libmach/hexify.c
View file

@ -4,7 +4,7 @@
#include <mach.h>
char *
_hexify(char *buf, ulong p, int zeros)
_hexify(char *buf, u64int p, int zeros)
{
ulong d;

25
src/libmach/loc.c
View file

@ -70,7 +70,7 @@ lget1(Map *map, Regs *regs, Loc loc, uchar *a, uint n)
int
lget2(Map *map, Regs *regs, Loc loc, u16int *u)
{
ulong ul;
u64int ul;
if(locsimplify(map, regs, loc, &loc) < 0)
return -1;
@ -93,7 +93,7 @@ lget2(Map *map, Regs *regs, Loc loc, u16int *u)
int
lget4(Map *map, Regs *regs, Loc loc, u32int *u)
{
ulong ul;
u64int ul;
if(locsimplify(map, regs, loc, &loc) < 0)
return -1;
@ -113,10 +113,23 @@ lget4(Map *map, Regs *regs, Loc loc, u32int *u)
return -1;
}
int
lgeta(Map *map, Regs *regs, Loc loc, u64int *u)
{
u32int v;
if(machcpu == &machamd64)
return lget8(map, regs, loc, u);
if(lget4(map, regs, loc, &v) < 0)
return -1;
*u = v;
return 4;
}
int
lget8(Map *map, Regs *regs, Loc loc, u64int *u)
{
ulong ul;
u64int ul;
if(locsimplify(map, regs, loc, &loc) < 0)
return -1;
@ -190,7 +203,7 @@ lput8(Map *map, Regs *regs, Loc loc, u64int u)
static Loc zl;
Loc
locaddr(ulong addr)
locaddr(u64int addr)
{
Loc l;
@ -214,7 +227,7 @@ locindir(char *reg, long offset)
}
Loc
locconst(ulong con)
locconst(u64int con)
{
Loc l;
@ -248,7 +261,7 @@ locreg(char *reg)
int
locsimplify(Map *map, Regs *regs, Loc loc, Loc *newloc)
{
ulong u;
u64int u;
if(loc.type == LOFFSET){
if(rget(regs, loc.reg, &u) < 0)

6
src/libmach/localaddr.c
View file

@ -18,9 +18,9 @@ static struct {
} rock;
static int
ltrace(Map *map, Regs *regs, ulong pc, ulong nextpc, Symbol *sym, int depth)
ltrace(Map *map, Regs *regs, u64int pc, u64int nextpc, Symbol *sym, int depth)
{
ulong v;
u64int v;
Symbol s1;
USED(pc);
@ -49,7 +49,7 @@ ltrace(Map *map, Regs *regs, ulong pc, ulong nextpc, Symbol *sym, int depth)
}
int
localaddr(Map *map, Regs *regs, char *fn, char *var, ulong *val)
localaddr(Map *map, Regs *regs, char *fn, char *var, u64int *val)
{
Regdesc *rp;

2095
src/libmach/mach386.c
View file

File diff suppressed because it is too large Load diff

197
src/libmach/machamd64.c Normal file
View file

@ -0,0 +1,197 @@
// Inferno libmach/6.c
// http://code.google.com/p/inferno-os/source/browse/utils/libmach/6.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 © 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.
/*
* amd64 definition
*/
#include <u.h>
#include <libc.h>
#include <bio.h>
#include <mach.h>
#include "uregamd64.h"
char *i386excep(Map*, Regs*);
int i386foll(Map*, Regs*, u64int, u64int*);
int i386hexinst(Map*, u64int, char*, int);
int i386das(Map*, u64int, char, char*, int);
int i386instlen(Map*, u64int);
int i386unwind(Map*, Regs*, u64int*, Symbol*);
#define REGOFF(x) offsetof(struct Ureg, x)
#define REGSIZE sizeof(struct Ureg)
#define FP_CTLS(x) (REGSIZE+2*(x))
#define FP_CTL(x) (REGSIZE+4*(x))
#define FP_REG(x) (FP_CTL(8)+16*(x))
#define XM_REG(x) (FP_CTL(8)+8*16+16*(x))
#define FPREGSIZE 512 /* TO DO? currently only 0x1A0 used */
static Regdesc amd64reglist[] = {
{"AX", REGOFF(ax), RINT, 'Y'},
{"BX", REGOFF(bx), RINT, 'Y'},
{"CX", REGOFF(cx), RINT, 'Y'},
{"DX", REGOFF(dx), RINT, 'Y'},
{"SI", REGOFF(si), RINT, 'Y'},
{"DI", REGOFF(di), RINT, 'Y'},
{"BP", REGOFF(bp), RINT, 'Y'},
{"R8", REGOFF(r8), RINT, 'Y'},
{"R9", REGOFF(r9), RINT, 'Y'},
{"R10", REGOFF(r10), RINT, 'Y'},
{"R11", REGOFF(r11), RINT, 'Y'},
{"R12", REGOFF(r12), RINT, 'Y'},
{"R13", REGOFF(r13), RINT, 'Y'},
{"R14", REGOFF(r14), RINT, 'Y'},
{"R15", REGOFF(r15), RINT, 'Y'},
{"DS", REGOFF(ds), RINT, 'x'},
{"ES", REGOFF(es), RINT, 'x'},
{"FS", REGOFF(fs), RINT, 'x'},
{"GS", REGOFF(gs), RINT, 'x'},
{"TYPE", REGOFF(type), RINT, 'Y'},
{"TRAP", REGOFF(type), RINT, 'Y'}, /* alias for acid */
{"ERROR", REGOFF(error), RINT, 'Y'},
{"IP", REGOFF(ip), RINT, 'Y'},
{"PC", REGOFF(ip), RINT, 'Y'}, /* alias for acid */
{"CS", REGOFF(cs), RINT, 'Y'},
{"FLAGS", REGOFF(flags), RINT, 'Y'},
{"SP", REGOFF(sp), RINT, 'Y'},
{"SS", REGOFF(ss), RINT, 'Y'},
{"FCW", FP_CTLS(0), RFLT, 'x'},
{"FSW", FP_CTLS(1), RFLT, 'x'},
{"FTW", FP_CTLS(2), RFLT, 'b'},
{"FOP", FP_CTLS(3), RFLT, 'x'},
{"RIP", FP_CTL(2), RFLT, 'Y'},
{"RDP", FP_CTL(4), RFLT, 'Y'},
{"MXCSR", FP_CTL(6), RFLT, 'X'},
{"MXCSRMASK", FP_CTL(7), RFLT, 'X'},
{"M0", FP_REG(0), RFLT, 'F'}, /* assumes double */
{"M1", FP_REG(1), RFLT, 'F'},
{"M2", FP_REG(2), RFLT, 'F'},
{"M3", FP_REG(3), RFLT, 'F'},
{"M4", FP_REG(4), RFLT, 'F'},
{"M5", FP_REG(5), RFLT, 'F'},
{"M6", FP_REG(6), RFLT, 'F'},
{"M7", FP_REG(7), RFLT, 'F'},
{"X0", XM_REG(0), RFLT, 'F'}, /* assumes double */
{"X1", XM_REG(1), RFLT, 'F'},
{"X2", XM_REG(2), RFLT, 'F'},
{"X3", XM_REG(3), RFLT, 'F'},
{"X4", XM_REG(4), RFLT, 'F'},
{"X5", XM_REG(5), RFLT, 'F'},
{"X6", XM_REG(6), RFLT, 'F'},
{"X7", XM_REG(7), RFLT, 'F'},
{"X8", XM_REG(8), RFLT, 'F'},
{"X9", XM_REG(9), RFLT, 'F'},
{"X10", XM_REG(10), RFLT, 'F'},
{"X11", XM_REG(11), RFLT, 'F'},
{"X12", XM_REG(12), RFLT, 'F'},
{"X13", XM_REG(13), RFLT, 'F'},
{"X14", XM_REG(14), RFLT, 'F'},
{"X15", XM_REG(15), RFLT, 'F'},
{"X16", XM_REG(16), RFLT, 'F'},
/*
{"F0", FP_REG(7), RFLT, '3'},
{"F1", FP_REG(6), RFLT, '3'},
{"F2", FP_REG(5), RFLT, '3'},
{"F3", FP_REG(4), RFLT, '3'},
{"F4", FP_REG(3), RFLT, '3'},
{"F5", FP_REG(2), RFLT, '3'},
{"F6", FP_REG(1), RFLT, '3'},
{"F7", FP_REG(0), RFLT, '3'},
*/
{ 0 }
};
static char *amd64windregs[] = {
"PC",
"SP",
"BP",
"AX",
"CX",
"DX",
"BX",
"SI",
"DI",
"R8",
"R9",
"R10",
"R11",
"R12",
"R13",
"R14",
"R15",
0,
};
Mach machamd64=
{
"amd64",
MAMD64, /* machine type */
amd64reglist, /* register list */
REGSIZE, /* size of registers in bytes */
FPREGSIZE, /* size of fp registers in bytes */
"PC", /* name of PC */
"SP", /* name of SP */
"BP", /* name of FP */
0, /* link register */
"setSB", /* static base register name (bogus anyways) */
0, /* static base register value */
0x1000, /* page size */
0xFFFFFFFF80110000ULL, /* kernel base */
0xFFFF800000000000ULL, /* kernel text mask */
1, /* quantization of pc */
8, /* szaddr */
4, /* szreg */
4, /* szfloat */
8, /* szdouble */
amd64windregs, /* locations unwound in stack trace */
17,
{0xCC, 0, 0, 0}, /* break point: INT 3 */
1, /* break point size */
i386foll, /* following addresses */
i386excep, /* print exception */
i386unwind, /* stack unwind */
leswap2, /* convert short to local byte order */
leswap4, /* convert long to local byte order */
leswap8, /* convert vlong to local byte order */
leieeeftoa32, /* single precision float pointer */
leieeeftoa64, /* double precision float pointer */
leieeeftoa80, /* long double precision floating point */
i386das, /* dissembler */
i386das, /* plan9-format disassembler */
0, /* commercial disassembler */
i386hexinst, /* print instruction */
i386instlen, /* instruction size calculation */
};

22
src/libmach/machpower.c
View file

@ -14,10 +14,10 @@
*/
static char *powerexcep(Map*, Regs*);
static int powerfoll(Map*, Regs*, ulong, ulong*);
static int powerdas(Map*, ulong, char, char*, int);
static int powerinstlen(Map*, ulong);
static int powerhexinst(Map*, ulong, char*, int);
static int powerfoll(Map*, Regs*, u64int, u64int*);
static int powerdas(Map*, u64int, char, char*, int);
static int powerinstlen(Map*, u64int);
static int powerhexinst(Map*, u64int, char*, int);
static char *excname[] =
{
@ -59,7 +59,7 @@ static char *excname[] =
static char*
powerexcep(Map *map, Regs *regs)
{
ulong c;
u64int c;
static char buf[32];
if(rget(regs, "CAUSE", &c) < 0)
@ -130,7 +130,7 @@ typedef struct {
long immediate;
long w0;
long w1;
ulong addr; /* pc of instruction */
u64int addr; /* pc of instruction */
short target;
char *curr; /* current fill level in output buffer */
char *end; /* end of buffer */
@ -1155,14 +1155,14 @@ printins(Map *map, ulong pc, char *buf, int n)
}
static int
powerdas(Map *map, ulong pc, char modifier, char *buf, int n)
powerdas(Map *map, u64int pc, char modifier, char *buf, int n)
{
USED(modifier);
return printins(map, pc, buf, n);
}
static int
powerhexinst(Map *map, ulong pc, char *buf, int n)
powerhexinst(Map *map, u64int pc, char *buf, int n)
{
Instr instr;
@ -1183,7 +1183,7 @@ powerhexinst(Map *map, ulong pc, char *buf, int n)
}
static int
powerinstlen(Map *map, ulong pc)
powerinstlen(Map *map, u64int pc)
{
Instr i;
@ -1194,7 +1194,7 @@ powerinstlen(Map *map, ulong pc)
}
static int
powerfoll(Map *map, Regs *regs, ulong pc, ulong *foll)
powerfoll(Map *map, Regs *regs, u64int pc, u64int *foll)
{
char *reg;
Instr i;
@ -1337,7 +1337,7 @@ static char *powerwindregs[] =
};
static int
powerunwind(Map *map, Regs *regs, ulong *next, Symbol *sym)
powerunwind(Map *map, Regs *regs, u64int *next, Symbol *sym)
{
/*
* This is tremendously hard. The best we're going to

3
src/libmach/manglegcc2.c
View file

@ -619,6 +619,9 @@ gccname(char **ps, char **pp)
break;
}
USED(p1);
USED(p0);
out:
*ps = s;
*pp = p;

53
src/libmach/map.c
View file

@ -6,10 +6,10 @@
#include <bio.h>
#include <mach.h>
static int fdrw(Map*, Seg*, ulong, void*, uint, int);
static int zerorw(Map*, Seg*, ulong, void*, uint, int);
static int mrw(Map*, ulong, void*, uint, int);
static int datarw(Map*, Seg*, ulong, void*, uint, int);
static int fdrw(Map*, Seg*, u64int, void*, uint, int);
static int zerorw(Map*, Seg*, u64int, void*, uint, int);
static int mrw(Map*, u64int, void*, uint, int);
static int datarw(Map*, Seg*, u64int, void*, uint, int);
Map*
allocmap(void)
@ -71,7 +71,7 @@ findseg(Map *map, char *name, char *file)
}
int
addrtoseg(Map *map, ulong addr, Seg *sp)
addrtoseg(Map *map, u64int addr, Seg *sp)
{
int i;
Seg *s;
@ -93,7 +93,7 @@ addrtoseg(Map *map, ulong addr, Seg *sp)
}
int
addrtosegafter(Map *map, ulong addr, Seg *sp)
addrtosegafter(Map *map, u64int addr, Seg *sp)
{
int i;
Seg *s, *best;
@ -142,13 +142,13 @@ removeseg(Map *map, int i)
}
int
get1(Map *map, ulong addr, uchar *a, uint n)
get1(Map *map, u64int addr, uchar *a, uint n)
{
return mrw(map, addr, a, n, 1);
}
int
get2(Map *map, ulong addr, u16int *u)
get2(Map *map, u64int addr, u16int *u)
{
u16int v;
@ -159,7 +159,7 @@ get2(Map *map, ulong addr, u16int *u)
}
int
get4(Map *map, ulong addr, u32int *u)
get4(Map *map, u64int addr, u32int *u)
{
u32int v;
@ -170,7 +170,7 @@ get4(Map *map, ulong addr, u32int *u)
}
int
get8(Map *map, ulong addr, u64int *u)
get8(Map *map, u64int addr, u64int *u)
{
u64int v;
@ -181,34 +181,47 @@ get8(Map *map, ulong addr, u64int *u)
}
int
put1(Map *map, ulong addr, uchar *a, uint n)
geta(Map *map, u64int addr, u64int *u)
{
u32int v;
if(machcpu == &machamd64)
return get8(map, addr, u);
if(get4(map, addr, &v) < 0)
return -1;
*u = v;
return 4;
}
int
put1(Map *map, u64int addr, uchar *a, uint n)
{
return mrw(map, addr, a, n, 0);
}
int
put2(Map *map, ulong addr, u16int u)
put2(Map *map, u64int addr, u16int u)
{
u = mach->swap2(u);
return mrw(map, addr, &u, 2, 0);
}
int
put4(Map *map, ulong addr, u32int u)
put4(Map *map, u64int addr, u32int u)
{
u = mach->swap4(u);
return mrw(map, addr, &u, 4, 0);
}
int
put8(Map *map, ulong addr, u64int u)
put8(Map *map, u64int addr, u64int u)
{
u = mach->swap8(u);
return mrw(map, addr, &u, 8, 0);
}
static Seg*
reloc(Map *map, ulong addr, uint n, ulong *off, uint *nn)
reloc(Map *map, u64int addr, uint n, u64int *off, uint *nn)
{
int i;
ulong o;
@ -236,12 +249,12 @@ reloc(Map *map, ulong addr, uint n, ulong *off, uint *nn)
}
static int
mrw(Map *map, ulong addr, void *a, uint n, int r)
mrw(Map *map, u64int addr, void *a, uint n, int r)
{
uint nn;
uint tot;
Seg *s;
ulong off;
u64int off;
for(tot=0; tot<n; tot+=nn){
s = reloc(map, addr+tot, n-tot, &off, &nn);
@ -254,7 +267,7 @@ mrw(Map *map, ulong addr, void *a, uint n, int r)
}
static int
fdrw(Map *map, Seg *seg, ulong addr, void *a, uint n, int r)
fdrw(Map *map, Seg *seg, u64int addr, void *a, uint n, int r)
{
int nn;
uint tot;
@ -279,7 +292,7 @@ fdrw(Map *map, Seg *seg, ulong addr, void *a, uint n, int r)
}
static int
zerorw(Map *map, Seg *seg, ulong addr, void *a, uint n, int r)
zerorw(Map *map, Seg *seg, u64int addr, void *a, uint n, int r)
{
USED(map);
USED(seg);
@ -294,7 +307,7 @@ zerorw(Map *map, Seg *seg, ulong addr, void *a, uint n, int r)
}
static int
datarw(Map *map, Seg *seg, ulong addr, void *a, uint n, int r)
datarw(Map *map, Seg *seg, u64int addr, void *a, uint n, int r)
{
USED(map);

2
src/libmach/mkfile
View file

@ -20,6 +20,7 @@ OFILES=\
elf.$O\
elfdl386.$O\
elfcorefreebsd386.$O\
elfcorefreebsdamd64.$O\
elfcorelinux386.$O\
frame.$O\
fpformat.$O\
@ -28,6 +29,7 @@ OFILES=\
loc.$O\
localaddr.$O\
mach386.$O\
machamd64.$O\
macho.$O\
machocorepower.$O\
machpower.$O\

6
src/libmach/regs.c
View file

@ -14,7 +14,7 @@ regdesc(char *name)
}
int
rput(Regs *regs, char *name, ulong u)
rput(Regs *regs, char *name, u64int u)
{
if(regs == nil){
werrstr("registers not mapped");
@ -24,7 +24,7 @@ rput(Regs *regs, char *name, ulong u)
}
int
rget(Regs *regs, char *name, ulong *u)
rget(Regs *regs, char *name, u64int *u)
{
if(regs == nil){
*u = ~(ulong)0;
@ -35,7 +35,7 @@ rget(Regs *regs, char *name, ulong *u)
}
int
_uregrw(Regs *regs, char *name, ulong *u, int isr)
_uregrw(Regs *regs, char *name, u64int *u, int isr)
{
Regdesc *r;
uchar *ureg;

16
src/libmach/sym.c
View file

@ -69,7 +69,7 @@ findhdr(char *name)
}
int
pc2file(ulong pc, char *file, uint nfile, ulong *line)
pc2file(u64int pc, char *file, uint nfile, ulong *line)
{
Fhdr *p;
@ -81,14 +81,14 @@ pc2file(ulong pc, char *file, uint nfile, ulong *line)
}
int
pc2line(ulong pc, ulong *line)
pc2line(u64int pc, ulong *line)
{
char tmp[10]; /* just in case */
return pc2file(pc, tmp, sizeof tmp, line);
}
int
file2pc(char *file, ulong line, ulong *addr)
file2pc(char *file, ulong line, u64int *addr)
{
Fhdr *p;
@ -102,7 +102,7 @@ file2pc(char *file, ulong line, ulong *addr)
}
int
line2pc(ulong basepc, ulong line, ulong *pc)
line2pc(u64int basepc, ulong line, u64int *pc)
{
Fhdr *p;
@ -116,7 +116,7 @@ line2pc(ulong basepc, ulong line, ulong *pc)
}
int
fnbound(ulong pc, ulong *bounds)
fnbound(u64int pc, u64int *bounds)
{
Fhdr *p;
Loc l;
@ -143,7 +143,7 @@ fnbound(ulong pc, ulong *bounds)
}
int
fileline(ulong pc, char *a, uint n)
fileline(u64int pc, char *a, uint n)
{
ulong line;
@ -408,7 +408,7 @@ findlsym(Symbol *s1, Loc loc, Symbol *s2)
}
int
unwindframe(Map *map, Regs *regs, ulong *next, Symbol *sym)
unwindframe(Map *map, Regs *regs, u64int *next, Symbol *sym)
{
Fhdr *p;
@ -421,7 +421,7 @@ unwindframe(Map *map, Regs *regs, ulong *next, Symbol *sym)
}
int
symoff(char *a, uint n, ulong addr, uint class)
symoff(char *a, uint n, u64int addr, uint class)
{
Loc l;
Symbol s;

18
src/libmach/symdwarf.c
View file

@ -6,14 +6,14 @@
#include "dwarf.h"
static void dwarfsymclose(Fhdr*);
static int dwarfpc2file(Fhdr*, ulong, char*, uint, ulong*);
static int dwarfline2pc(Fhdr*, ulong, ulong, ulong*);
static int dwarfpc2file(Fhdr*, u64int, char*, uint, ulong*);
static int dwarfline2pc(Fhdr*, u64int, ulong, u64int*);
static int dwarflookuplsym(Fhdr*, Symbol*, char*, Symbol*);
static int dwarfindexlsym(Fhdr*, Symbol*, uint, Symbol*);
static int dwarffindlsym(Fhdr*, Symbol*, Loc, Symbol*);
static void dwarfsyminit(Fhdr*);
static int dwarftosym(Fhdr*, Dwarf*, DwarfSym*, Symbol*, int);
static int _dwarfunwind(Fhdr *fhdr, Map *map, Regs *regs, ulong *next, Symbol*);
static int _dwarfunwind(Fhdr *fhdr, Map *map, Regs *regs, u64int *next, Symbol*);
int
symdwarf(Fhdr *hdr)
@ -43,7 +43,7 @@ dwarfsymclose(Fhdr *hdr)
}
static int
dwarfpc2file(Fhdr *fhdr, ulong pc, char *buf, uint nbuf, ulong *line)
dwarfpc2file(Fhdr *fhdr, u64int pc, char *buf, uint nbuf, ulong *line)
{
char *cdir, *dir, *file;
@ -61,7 +61,7 @@ dwarfpc2file(Fhdr *fhdr, ulong pc, char *buf, uint nbuf, ulong *line)
}
static int
dwarfline2pc(Fhdr *fhdr, ulong basepc, ulong line, ulong *pc)
dwarfline2pc(Fhdr *fhdr, u64int basepc, ulong line, u64int *pc)
{
werrstr("dwarf line2pc not implemented");
return -1;
@ -323,11 +323,11 @@ dwarftosym(Fhdr *fp, Dwarf *d, DwarfSym *ds, Symbol *s, int infn)
}
static int
dwarfeval(Dwarf *d, Map *map, Regs *regs, ulong cfa, int rno, DwarfExpr e, ulong *u)
dwarfeval(Dwarf *d, Map *map, Regs *regs, ulong cfa, int rno, DwarfExpr e, u64int *u)
{
int i;
u32int u4;
ulong uu;
u64int uu;
switch(e.type){
case RuleUndef:
@ -396,11 +396,11 @@ dwarfexprfmt(Fmt *fmt)
#endif
static int
_dwarfunwind(Fhdr *fhdr, Map *map, Regs *regs, ulong *next, Symbol *sym)
_dwarfunwind(Fhdr *fhdr, Map *map, Regs *regs, u64int *next, Symbol *sym)
{
char *name;
int i, j;
ulong cfa, pc, u;
u64int cfa, pc, u;
Dwarf *d;
DwarfExpr *e, epc, ecfa;

5
src/libmach/symstabs.c
View file

@ -254,6 +254,7 @@ stabssyminit(Fhdr *fp)
break;
}
}
USED(locals);
free(inc);
return 0;
@ -263,7 +264,7 @@ err:
}
static int
stabspc2file(Fhdr *fhdr, ulong pc, char *buf, uint nbuf, ulong *pline)
stabspc2file(Fhdr *fhdr, u64int pc, char *buf, uint nbuf, ulong *pline)
{
int i;
Symbol *s;
@ -298,7 +299,7 @@ stabspc2file(Fhdr *fhdr, ulong pc, char *buf, uint nbuf, ulong *pline)
}
static int
stabsline2pc(Fhdr *fhdr, ulong startpc, ulong line, ulong *pc)
stabsline2pc(Fhdr *fhdr, u64int startpc, ulong line, u64int *pc)
{
int i, trigger;
Symbol *s;

58
src/libmach/uregamd64.h Normal file
View file

@ -0,0 +1,58 @@
// Inferno utils/libmach/ureg6.h
// http://code.google.com/p/inferno-os/source/browse/utils/libmach/ureg6.h
//
// 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 © 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.
struct Ureg {
u64int ax;
u64int bx;
u64int cx;
u64int dx;
u64int si;
u64int di;
u64int bp;
u64int r8;
u64int r9;
u64int r10;
u64int r11;
u64int r12;
u64int r13;
u64int r14;
u64int r15;
u16int ds;
u16int es;
u16int fs;
u16int gs;
u64int type;
u64int error; /* error code (or zero) */
u64int ip; /* pc */
u64int cs; /* old context */
u64int flags; /* old flags */
u64int sp; /* sp */
u64int ss; /* old stack segment */
};