Intravision/reactos
1
0
Fork 0
mirror of https://github.com/reactos/reactos.git synced 2024-07-01 18:24:24 +00:00
Code Issues Packages Projects Releases Wiki Activity

[NTOSKRNL]

Browse source 
Merge r52027 from cmake branch:
* Several improvements to debug symbols handling.
* A new (killer/awesome/...etc) feature has been introduced to kdbg: argument values support. Now backtraces contain not only usermode and kernelmode addresses translated, but also the argument values passed to the functions along the trace.
* Brought to you by the Arty.
* works only with cmake builds

svn path=/trunk/; revision=52050
This commit is contained in:
Timo Kreuzer 2011-06-01 20:36:40 +00:00
parent 2489556d2b
commit 295bc5ef26
23 changed files with 1900 additions and 1306 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

70
reactos/include/reactos/rossym.h
View file

@ -26,11 +26,72 @@ typedef struct _ROSSYM_ENTRY {
ULONG SourceLine; ULONG SourceLine;
} ROSSYM_ENTRY, *PROSSYM_ENTRY; } ROSSYM_ENTRY, *PROSSYM_ENTRY;
enum _ROSSYM_REGNAME {
ROSSYM_X86_EAX = 0,
ROSSYM_X86_ECX,
ROSSYM_X86_EDX,
ROSSYM_X86_EBX,
ROSSYM_X86_ESP,
ROSSYM_X86_EBP,
ROSSYM_X86_ESI,
ROSSYM_X86_EDI,
ROSSYM_X64_RAX = 0,
ROSSYM_X64_RDX,
ROSSYM_X64_RCX,
ROSSYM_X64_RBX,
ROSSYM_X64_RSI,
ROSSYM_X64_RDI,
ROSSYM_X64_RBP,
ROSSYM_X64_RSP,
Rossym_X64_R8,
ROSSYM_X64_R9,
ROSSYM_X64_R10,
ROSSYM_X64_R11,
ROSSYM_X64_R12,
ROSSYM_X64_R13,
ROSSYM_X64_R14,
ROSSYM_X64_R15
};
typedef struct _ROSSYM_REGISTERS {
ULONGLONG Registers[32];
} ROSSYM_REGISTERS, *PROSSYM_REGISTERS;
typedef struct _ROSSYM_PARAMETER {
ULONGLONG Value;
char *ValueName;
} ROSSYM_PARAMETER, *PROSSYM_PARAMETER;
typedef enum _ROSSYM_LINEINFO_FLAGS {
ROSSYM_LINEINFO_HAS_REGISTERS = 1
} ROSSYM_LINEINFO_FLAGS;
typedef enum _ROSSYM_LINEINFO_TYPE {
ROSSYM_LINEINFO_UNKNOWN,
ROSSYM_LINEINFO_NARROW_STRING,
ROSSYM_LINEINFO_WIDE_STRING,
ROSSYM_LINEINFO_ANSI_STRING,
ROSSYM_LINEINFO_UNICODE_STRING,
ROSSYM_LINEINFO_HANDLE
} ROSSYM_LINEINFO_STRINGTYPE;
typedef struct _ROSSYM_LINEINFO {
ROSSYM_LINEINFO_FLAGS Flags;
ULONG LineNumber;
char *FileName;
char *FunctionName;
ROSSYM_REGISTERS Registers;
ULONG NumParams;
ROSSYM_PARAMETER Parameters[16];
} ROSSYM_LINEINFO, *PROSSYM_LINEINFO;
typedef struct _ROSSYM_CALLBACKS { typedef struct _ROSSYM_CALLBACKS {
PVOID (*AllocMemProc)(ULONG_PTR Size); PVOID (*AllocMemProc)(ULONG_PTR Size);
VOID (*FreeMemProc)(PVOID Area); VOID (*FreeMemProc)(PVOID Area);
BOOLEAN (*ReadFileProc)(PVOID FileContext, PVOID Buffer, ULONG Size); BOOLEAN (*ReadFileProc)(PVOID FileContext, PVOID Buffer, ULONG Size);
BOOLEAN (*SeekFileProc)(PVOID FileContext, ULONG_PTR Position); BOOLEAN (*SeekFileProc)(PVOID FileContext, ULONG_PTR Position);
BOOLEAN (*MemGetProc)(PVOID FileContext, ULONG_PTR *Target, PVOID SourceMem, ULONG Size);
} ROSSYM_CALLBACKS, *PROSSYM_CALLBACKS; } ROSSYM_CALLBACKS, *PROSSYM_CALLBACKS;
#ifdef __ROS_CMAKE__ #ifdef __ROS_CMAKE__
@ -46,7 +107,9 @@ typedef struct _ROSSYM_INFO *PROSSYM_INFO;
#endif #endif
VOID RosSymInit(PROSSYM_CALLBACKS Callbacks); VOID RosSymInit(PROSSYM_CALLBACKS Callbacks);
#ifndef __ROS_CMAKE__
VOID RosSymInitKernelMode(VOID); VOID RosSymInitKernelMode(VOID);
#endif
VOID RosSymInitUserMode(VOID); VOID RosSymInitUserMode(VOID);
BOOLEAN RosSymCreateFromRaw(PVOID RawData, ULONG_PTR DataSize, BOOLEAN RosSymCreateFromRaw(PVOID RawData, ULONG_PTR DataSize,
@ -56,11 +119,18 @@ BOOLEAN RosSymCreateFromMem(PVOID ImageStart, ULONG_PTR ImageSize,
BOOLEAN RosSymCreateFromFile(PVOID FileContext, PROSSYM_INFO *RosSymInfo); BOOLEAN RosSymCreateFromFile(PVOID FileContext, PROSSYM_INFO *RosSymInfo);
ULONG RosSymGetRawDataLength(PROSSYM_INFO RosSymInfo); ULONG RosSymGetRawDataLength(PROSSYM_INFO RosSymInfo);
VOID RosSymGetRawData(PROSSYM_INFO RosSymInfo, PVOID RawData); VOID RosSymGetRawData(PROSSYM_INFO RosSymInfo, PVOID RawData);
#ifdef __ROS_CMAKE__
BOOLEAN RosSymGetAddressInformation(PROSSYM_INFO RosSymInfo,
ULONG_PTR RelativeAddress,
PROSSYM_LINEINFO RosSymLineInfo);
#else
BOOLEAN RosSymGetAddressInformation(PROSSYM_INFO RosSymInfo, BOOLEAN RosSymGetAddressInformation(PROSSYM_INFO RosSymInfo,
ULONG_PTR RelativeAddress, ULONG_PTR RelativeAddress,
ULONG *LineNumber, ULONG *LineNumber,
char *FileName, char *FileName,
char *FunctionName); char *FunctionName);
#endif
VOID RosSymFreeInfo(PROSSYM_LINEINFO RosSymLineInfo);
VOID RosSymDelete(PROSSYM_INFO RosSymInfo); VOID RosSymDelete(PROSSYM_INFO RosSymInfo);
#endif /* REACTOS_ROSSYM_H_INCLUDED */ #endif /* REACTOS_ROSSYM_H_INCLUDED */

3
reactos/lib/rossym_new/CMakeLists.txt
View file

@ -5,7 +5,6 @@ else()
add_definitions(-D_NTSYSTEM_) add_definitions(-D_NTSYSTEM_)
list(APPEND SOURCE list(APPEND SOURCE
delete.c delete.c
dwarf386.c
dwarfabbrev.c dwarfabbrev.c
dwarfaranges.c dwarfaranges.c
dwarfcfa.c dwarfcfa.c
@ -16,9 +15,7 @@ list(APPEND SOURCE
dwarfpubnames.c dwarfpubnames.c
find.c find.c
fromfile.c fromfile.c
iofile.c
init.c init.c
initkm.c
initum.c initum.c
pe.c pe.c
zwfile.c) zwfile.c)

2
reactos/lib/rossym_new/compat.h
View file

@ -32,6 +32,8 @@ void *RosSymRealloc(void *mem, ulong newsize);
void xfree(void *v); void xfree(void *v);
#define werrstr(str, ...) DPRINT(str "\n" ,##__VA_ARGS__) #define werrstr(str, ...) DPRINT(str "\n" ,##__VA_ARGS__)
//#define werrstr(x, ...) printf("(%s:%d) " x "\n",__FILE__,__LINE__,##__VA_ARGS__)
#define malloc(x) RosSymAllocMem(x) #define malloc(x) RosSymAllocMem(x)
#define mallocz(x,y) RosSymAllocMemZero(x,y) #define mallocz(x,y) RosSymAllocMemZero(x,y)
#define free(x) xfree(x) #define free(x) xfree(x)

56
reactos/lib/rossym_new/dwarf.h
View file

@ -6,6 +6,8 @@ typedef struct DwarfBlock DwarfBlock;
typedef struct DwarfBuf DwarfBuf; typedef struct DwarfBuf DwarfBuf;
typedef struct DwarfExpr DwarfExpr; typedef struct DwarfExpr DwarfExpr;
typedef struct DwarfSym DwarfSym; typedef struct DwarfSym DwarfSym;
typedef struct DwarfStack DwarfStack;
typedef struct DwarfParam DwarfParam;
typedef union DwarfVal DwarfVal; typedef union DwarfVal DwarfVal;
enum enum
@ -203,6 +205,16 @@ struct DwarfBlock
ulong len; ulong len;
}; };
struct DwarfParam
{
char *name;
ulong unit;
ulong type;
ulong loctype;
ulong fde, len;
ulong value;
};
/* not for consumer use */ /* not for consumer use */
struct DwarfBuf struct DwarfBuf
{ {
@ -372,19 +384,16 @@ struct DwarfExpr
struct DwarfSym struct DwarfSym
{ {
DwarfAttrs attrs; DwarfAttrs attrs;
/* not for consumer use... */ /* not for consumer use... */
DwarfBuf b; uint num;
ulong unit; DwarfBuf b;
uint uoff; int depth;
ulong aoff; ulong unit, childoff, nextunit;
int depth; ulong aoff;
int allunits;
ulong nextunit;
}; };
struct _Pe; struct _Pe;
Dwarf *dwarfopen(struct _Pe *elf); Dwarf *dwarfopen(struct _Pe *elf);
void dwarfclose(Dwarf*); void dwarfclose(Dwarf*);
@ -398,9 +407,11 @@ int dwarfenumunit(Dwarf*, ulong, DwarfSym*);
int dwarfseeksym(Dwarf*, ulong, ulong, DwarfSym*); int dwarfseeksym(Dwarf*, ulong, ulong, DwarfSym*);
int dwarfenum(Dwarf*, DwarfSym*); int dwarfenum(Dwarf*, DwarfSym*);
int dwarfnextsym(Dwarf*, DwarfSym*); int dwarfnextsym(Dwarf*, DwarfSym*);
int dwarfnextsymat(Dwarf*, DwarfSym*, int); int dwarfnextsymat(Dwarf*, DwarfSym *parent, DwarfSym *child);
int dwarfpctoline(Dwarf*, ulong, char**, char**, char**, char **, ulong*, ulong*, ulong*); int dwarfpctoline(Dwarf*, DwarfSym *proc, ulong, char**, char**, ulong *);
int dwarfunwind(Dwarf*, ulong, DwarfExpr*, DwarfExpr*, DwarfExpr*, int); int dwarfgetarg(Dwarf *d, const char *name, DwarfBuf *locbuf, ulong cfa, PROSSYM_REGISTERS registers, ulong *value);
int dwarfgettype(Dwarf *d, DwarfSym *param, DwarfSym *type);
ulong dwarfget1(DwarfBuf*); ulong dwarfget1(DwarfBuf*);
ulong dwarfget2(DwarfBuf*); ulong dwarfget2(DwarfBuf*);
ulong dwarfget4(DwarfBuf*); ulong dwarfget4(DwarfBuf*);
@ -411,7 +422,10 @@ ulong dwarfgetaddr(DwarfBuf*);
int dwarfgetn(DwarfBuf*, uchar*, int); int dwarfgetn(DwarfBuf*, uchar*, int);
uchar *dwarfgetnref(DwarfBuf*, ulong); uchar *dwarfgetnref(DwarfBuf*, ulong);
char *dwarfgetstring(DwarfBuf*); char *dwarfgetstring(DwarfBuf*);
int dwarfcomputecfa(Dwarf *d, DwarfExpr *cfa, PROSSYM_REGISTERS registers, ulong *cfaLocation);
int dwarfregunwind(Dwarf *d, ulong pc, ulong fde, DwarfExpr *cfa, PROSSYM_REGISTERS registers);
int dwarfargvalue(Dwarf *d, DwarfSym *proc, ulong pc, ulong cfa, PROSSYM_REGISTERS registers, DwarfParam *parameters);
int dwarfgetparams(Dwarf *d, DwarfSym *s, ulong pc, int pnum, DwarfParam *paramblocks);
typedef struct DwarfAbbrev DwarfAbbrev; typedef struct DwarfAbbrev DwarfAbbrev;
typedef struct DwarfAttr DwarfAttr; typedef struct DwarfAttr DwarfAttr;
@ -449,6 +463,7 @@ struct Dwarf
DwarfBlock pubtypes; DwarfBlock pubtypes;
DwarfBlock ranges; DwarfBlock ranges;
DwarfBlock str; DwarfBlock str;
DwarfBlock loc;
/* little cache */ /* little cache */
struct { struct {
@ -458,14 +473,15 @@ struct Dwarf
} acache; } acache;
}; };
struct DwarfStack
{
ulong storage[16]; // own storage
ulong *data;
ulong length, max;
};
DwarfAbbrev *dwarfgetabbrev(Dwarf*, ulong, ulong); DwarfAbbrev *dwarfgetabbrev(Dwarf*, ulong, ulong);
int dwarfgetinfounit(Dwarf*, ulong, DwarfBlock*); int dwarfgetinfounit(Dwarf*, ulong, DwarfBlock*);
extern int dwarf386nregs;
extern char *dwarf386regs[];
extern char *dwarf386fp;
#define SYMBOL_SIZE 18
#define MAXIMUM_DWARF_NAME_SIZE 64 #define MAXIMUM_DWARF_NAME_SIZE 64
#define MAXIMUM_COFF_SYMBOL_LENGTH 256

174
reactos/lib/rossym_new/dwarfabbrev.c
View file

@ -25,117 +25,119 @@ DwarfAbbrev *dwarfgetabbrev(Dwarf*, ulong, ulong);
static int static int
loadabbrevs(Dwarf *d, ulong off, DwarfAbbrev **aa) loadabbrevs(Dwarf *d, ulong off, DwarfAbbrev **aa)
{ {
int nattr, nabbrev; int nattr, nabbrev;
DwarfAbbrev *abbrev; DwarfAbbrev *abbrev;
DwarfAttr *attr; DwarfAttr *attr;
if(d->acache.off == off && d->acache.na){ if(d->acache.off == off && d->acache.na){
*aa = d->acache.a; *aa = d->acache.a;
return d->acache.na; return d->acache.na;
} }
/* two passes - once to count, then allocate, then a second to copy */ /* two passes - once to count, then allocate, then a second to copy */
if(parseabbrevs(d, off, nil, nil, &nabbrev, &nattr) < 0) { if(parseabbrevs(d, off, nil, nil, &nabbrev, &nattr) < 0) {
return -1; return -1;
} }
abbrev = malloc(nabbrev*sizeof(DwarfAbbrev) + nattr*sizeof(DwarfAttr)); abbrev = malloc(nabbrev*sizeof(DwarfAbbrev) + nattr*sizeof(DwarfAttr));
attr = (DwarfAttr*)(abbrev+nabbrev); attr = (DwarfAttr*)(abbrev+nabbrev);
if(parseabbrevs(d, off, abbrev, attr, nil, nil) < 0){ if(parseabbrevs(d, off, abbrev, attr, nil, nil) < 0){
free(abbrev); free(abbrev);
return -1; return -1;
} }
free(d->acache.a); free(d->acache.a);
d->acache.a = abbrev; d->acache.a = abbrev;
d->acache.na = nabbrev; d->acache.na = nabbrev;
d->acache.off = off; d->acache.off = off;
*aa = abbrev; *aa = abbrev;
return nabbrev; return nabbrev;
} }
static int static int
parseabbrevs(Dwarf *d, ulong off, DwarfAbbrev *abbrev, DwarfAttr *attr, int *pnabbrev, int *pnattr) parseabbrevs(Dwarf *d, ulong off, DwarfAbbrev *abbrev, DwarfAttr *attr, int *pnabbrev, int *pnattr)
{ {
int i, nabbrev, nattr, haskids; int i, nabbrev, nattr, haskids;
ulong num, tag, name, form; ulong num, tag, name, form;
DwarfBuf b; DwarfBuf b;
if(off >= d->abbrev.len){ if(off >= d->abbrev.len){
werrstr("bad abbrev section offset 0x%lux >= 0x%lux\n", off, d->abbrev.len); werrstr("bad abbrev section offset 0x%lux >= 0x%lux", off, d->abbrev.len);
return -1; return -1;
} }
memset(&b, 0, sizeof b); memset(&b, 0, sizeof b);
b.p = d->abbrev.data + off; b.p = d->abbrev.data + off;
b.ep = d->abbrev.data + d->abbrev.len; b.ep = d->abbrev.data + d->abbrev.len;
nabbrev = 0; nabbrev = 0;
nattr = 0; nattr = 0;
for(;;){ for(;;){
if(b.p == nil){ if(b.p == nil){
werrstr("malformed abbrev data"); werrstr("malformed abbrev data");
return -1; return -1;
} }
num = dwarfget128(&b); num = dwarfget128(&b);
if(num == 0) if(num == 0)
break; break;
tag = dwarfget128(&b); tag = dwarfget128(&b);
haskids = dwarfget1(&b); DPRINT("num %d tag %x @ %x", num, tag, b.p - d->abbrev.data);
for(i=0;; i++){ haskids = dwarfget1(&b);
name = dwarfget128(&b); for(i=0;; i++){
form = dwarfget128(&b); name = dwarfget128(&b);
if(name == 0 && form == 0) form = dwarfget128(&b);
break; assert(form < 0x3000);
if(attr){ if(name == 0 && form == 0)
attr[i].name = name; break;
attr[i].form = form; if(attr){
} attr[i].name = name;
} attr[i].form = form;
if(abbrev){ }
abbrev->num = num; }
abbrev->tag = tag; if(abbrev){
abbrev->haskids = haskids; abbrev->num = num;
abbrev->attr = attr; abbrev->tag = tag;
abbrev->nattr = i; abbrev->haskids = haskids;
abbrev++; abbrev->attr = attr;
attr += i; abbrev->nattr = i;
} abbrev++;
nabbrev++; attr += i;
nattr += i; }
} nabbrev++;
if(pnabbrev) nattr += i;
*pnabbrev = nabbrev; }
if(pnattr) if(pnabbrev)
*pnattr = nattr; *pnabbrev = nabbrev;
return 0; if(pnattr)
*pnattr = nattr;
return 0;
} }
static DwarfAbbrev* static DwarfAbbrev*
findabbrev(DwarfAbbrev *a, int na, ulong num) findabbrev(DwarfAbbrev *a, int na, ulong num)
{ {
int i; int i;
for(i=0; i<na; i++) for(i=0; i<na; i++)
if(a[i].num == num) if(a[i].num == num)
return &a[i]; return &a[i];
werrstr("abbrev not found"); assert(0);
return nil; werrstr("abbrev not found");
return nil;
} }
DwarfAbbrev* DwarfAbbrev*
dwarfgetabbrev(Dwarf *d, ulong off, ulong num) dwarfgetabbrev(Dwarf *d, ulong off, ulong num)
{ {
DwarfAbbrev *a; DwarfAbbrev *a;
int na; int na;
if((na = loadabbrevs(d, off, &a)) < 0){ if((na = loadabbrevs(d, off, &a)) < 0){
werrstr("loadabbrevs: %r"); werrstr("loadabbrevs: %r");
return nil; return nil;
} }
return findabbrev(a, na, num); return findabbrev(a, na, num);
} }

98
reactos/lib/rossym_new/dwarfaranges.c
View file

@ -16,56 +16,54 @@
int int
dwarfaddrtounit(Dwarf *d, ulong addr, ulong *unit) dwarfaddrtounit(Dwarf *d, ulong addr, ulong *unit)
{ {
DwarfBuf b; DwarfBuf b;
int segsize, i; int segsize, i;
ulong len, id, off, base, size; ulong len, id, off, base, size;
uchar *start, *end; uchar *start, *end;
memset(&b, 0, sizeof b); memset(&b, 0, sizeof b);
b.d = d; b.d = d;
b.p = d->aranges.data; b.p = d->aranges.data;
b.ep = b.p + d->aranges.len; b.ep = b.p + d->aranges.len;
while(b.p < b.ep){ while(b.p < b.ep){
start = b.p; start = b.p;
len = dwarfget4(&b); len = dwarfget4(&b);
if (!len) { b.ep = b.p - 4; return -1; } if (!len) { b.ep = b.p - 4; return -1; }
if((id = dwarfget2(&b)) != 2){ if((id = dwarfget2(&b)) != 2){
if(b.p == nil){ if(b.p == nil){
underflow: underflow:
werrstr("buffer underflow reading address ranges header"); werrstr("buffer underflow reading address ranges header");
}else }else
werrstr("bad dwarf version 0x%x in address ranges header", id); werrstr("bad dwarf version 0x%x in address ranges header", id);
return -1; return -1;
} }
off = dwarfget4(&b); off = dwarfget4(&b);
b.addrsize = dwarfget1(&b); b.addrsize = dwarfget1(&b);
if(d->addrsize == 0) if(d->addrsize == 0)
d->addrsize = b.addrsize; d->addrsize = b.addrsize;
segsize = dwarfget1(&b); segsize = dwarfget1(&b);
USED(segsize); /* what am i supposed to do with this? */ USED(segsize); /* what am i supposed to do with this? */
if(b.p == nil) if(b.p == nil)
goto underflow; goto underflow;
if((i = (b.p-start) % (2*b.addrsize)) != 0) if((i = (b.p-start) % (2*b.addrsize)) != 0)
b.p += 2*b.addrsize - i; b.p += 2*b.addrsize - i;
end = start+4+len; end = start+4+len;
while(b.p!=nil && b.p<end){ while(b.p!=nil && b.p<end){
base = dwarfgetaddr(&b); base = dwarfgetaddr(&b);
size = dwarfgetaddr(&b); size = dwarfgetaddr(&b);
if (!size) continue; if (!size) continue;
if(b.p == nil) if(b.p == nil)
goto underflow; goto underflow;
if(base <= addr && addr < base+size){ if(base <= addr && addr < base+size){
*unit = off; *unit = off;
return 0; return 0;
} }
} }
if(b.p == nil) if(b.p == nil)
goto underflow; goto underflow;
b.p = end; b.p = end;
} }
werrstr("address 0x%lux is not listed in dwarf debugging symbols", addr); werrstr("address 0x%lux is not listed in dwarf debugging symbols", addr);
return -1; return -1;
} }

143
reactos/lib/rossym_new/dwarfcfa.c
View file

@ -17,9 +17,10 @@
#define NDEBUG #define NDEBUG
#include <debug.h> #include <debug.h>
#include "pe.h"
#include "dwarf.h" #include "dwarf.h"
#define trace 0 #define trace 1
typedef struct State State; typedef struct State State;
struct State struct State
@ -71,7 +72,7 @@ dwarfunwind(Dwarf *d, ulong pc, DwarfExpr *cfa, DwarfExpr *ra, DwarfExpr *r, int
memset(r, 0, nr*sizeof(r[0])); memset(r, 0, nr*sizeof(r[0]));
for(i=0; i<nr; i++) for(i=0; i<nr; i++)
r[i].type = RuleSame; r[i].type = RuleSame;
if(trace) werrstr("s.init %p-%p, fde %p-%p\n", s.init.p, s.init.ep, fde.p, fde.ep); if(trace) werrstr("s.init %p-%p, fde %p-%p", s.init.p, s.init.ep, fde.p, fde.ep);
b = s.init; b = s.init;
if(dexec(&b, &s, 0) < 0) if(dexec(&b, &s, 0) < 0)
goto err; goto err;
@ -79,9 +80,9 @@ dwarfunwind(Dwarf *d, ulong pc, DwarfExpr *cfa, DwarfExpr *ra, DwarfExpr *r, int
s.initr = initr; s.initr = initr;
memmove(initr, r, nr*sizeof(initr[0])); memmove(initr, r, nr*sizeof(initr[0]));
if(trace) werrstr("s.loc 0x%lux pc 0x%lux\n", s.loc, pc); if(trace) werrstr("s.loc 0x%lx pc 0x%lx", s.loc, pc);
while(s.loc < pc){ while(s.loc < pc){
if(trace) werrstr("s.loc 0x%lux pc 0x%lux\n", s.loc, pc); if(trace) werrstr("s.loc 0x%lx pc 0x%lx", s.loc, pc);
if(dexec(&fde, &s, 1) < 0) if(dexec(&fde, &s, 1) < 0)
goto err; goto err;
} }
@ -139,15 +140,16 @@ findfde(Dwarf *d, ulong pc, State *s, DwarfBuf *fde)
id = dwarfget4(&b); id = dwarfget4(&b);
if(id == 0xFFFFFFFF){ /* CIE */ if(id == 0xFFFFFFFF){ /* CIE */
vers = dwarfget1(&b); vers = dwarfget1(&b);
if (trace) werrstr("CIE len %x id %x vers %x", len, id, vers);
if(vers != 1 && vers != 2 && vers != 3){ if(vers != 1 && vers != 2 && vers != 3){
if(++nbad == 1) if(++nbad == 1)
werrstr("unknown cie version %d (wanted 1-3)\n", vers); werrstr("unknown cie version %d (wanted 1-3)", vers);
continue; continue;
} }
aug = dwarfgetstring(&b); aug = dwarfgetstring(&b);
if(aug && *aug){ if(aug && *aug){
if(++nbad == 1) if(++nbad == 1)
werrstr("unknown augmentation: %s\n", aug); werrstr("unknown augmentation: %s", aug);
continue; continue;
} }
s->iquantum = dwarfget128(&b); s->iquantum = dwarfget128(&b);
@ -163,6 +165,7 @@ findfde(Dwarf *d, ulong pc, State *s, DwarfBuf *fde)
}else{ /* FDE */ }else{ /* FDE */
base = dwarfgetaddr(&b); base = dwarfgetaddr(&b);
size = dwarfgetaddr(&b); size = dwarfgetaddr(&b);
if (trace) werrstr("FDE: base %x-%x (want pc %x)", base, base+size, pc);
fde->p = b.p; fde->p = b.p;
fde->ep = next; fde->ep = next;
s->loc = base; s->loc = base;
@ -171,7 +174,7 @@ findfde(Dwarf *d, ulong pc, State *s, DwarfBuf *fde)
return 0; return 0;
} }
} }
werrstr("cannot find call frame information for pc 0x%lux", pc); werrstr("cannot find call frame information for pc 0x%lx", pc);
return -1; return -1;
} }
@ -180,7 +183,7 @@ static int
checkreg(State *s, long r) checkreg(State *s, long r)
{ {
if(r < 0 || r >= s->nr){ if(r < 0 || r >= s->nr){
werrstr("bad register number 0x%lux", r); werrstr("bad register number 0x%lx", r);
return -1; return -1;
} }
return 0; return 0;
@ -197,20 +200,21 @@ dexec(DwarfBuf *b, State *s, int locstop)
if(b->p == b->ep){ if(b->p == b->ep){
if(s->initr) if(s->initr)
s->loc = s->endloc; s->loc = s->endloc;
werrstr("end dexec");
return 0; return 0;
} }
c = dwarfget1(b); c = dwarfget1(b);
if(b->p == nil){ if(b->p == nil){
werrstr("ran out of instructions during cfa program"); werrstr("ran out of instructions during cfa program");
if(trace) werrstr("%r\n"); if(trace) werrstr("%r");
return -1; return -1;
} }
if(trace) werrstr("+ loc=0x%lux op 0x%ux ", s->loc, c); if(trace) werrstr("+ loc=0x%x op 0x%x ", s->loc, c);
switch(c>>6){ switch(c>>6){
case 1: /* advance location */ case 1: /* advance location */
arg1 = c&0x3F; arg1 = c&0x3F;
advance: advance:
if(trace) werrstr("loc += %ld\n", arg1*s->iquantum); if(trace) werrstr("loc += %ld", arg1*s->iquantum);
s->loc += arg1 * s->iquantum; s->loc += arg1 * s->iquantum;
if(locstop) if(locstop)
return 0; return 0;
@ -220,7 +224,7 @@ dexec(DwarfBuf *b, State *s, int locstop)
arg1 = c&0x3F; arg1 = c&0x3F;
arg2 = dwarfget128(b); arg2 = dwarfget128(b);
offset: offset:
if(trace) werrstr("r%ld += %ld\n", arg1, arg2*s->dquantum); if(trace) werrstr("r%ld += %ld", arg1, arg2*s->dquantum);
if(checkreg(s, arg1) < 0) if(checkreg(s, arg1) < 0)
return -1; return -1;
s->r[arg1].type = RuleCfaOffset; s->r[arg1].type = RuleCfaOffset;
@ -230,7 +234,7 @@ dexec(DwarfBuf *b, State *s, int locstop)
case 3: /* restore initial setting */ case 3: /* restore initial setting */
arg1 = c&0x3F; arg1 = c&0x3F;
restore: restore:
if(trace) werrstr("r%ld = init\n", arg1); if(trace) werrstr("r%ld = init", arg1);
if(checkreg(s, arg1) < 0) if(checkreg(s, arg1) < 0)
return -1; return -1;
s->r[arg1] = s->initr[arg1]; s->r[arg1] = s->initr[arg1];
@ -239,12 +243,12 @@ dexec(DwarfBuf *b, State *s, int locstop)
switch(c){ switch(c){
case 0: /* nop */ case 0: /* nop */
if(trace) werrstr("nop\n"); if(trace) werrstr("nop");
continue; continue;
case 0x01: /* set location */ case 0x01: /* set location */
s->loc = dwarfgetaddr(b); s->loc = dwarfgetaddr(b);
if(trace) werrstr("loc = 0x%lux\n", s->loc); if(trace) werrstr("loc = 0x%lx", s->loc);
if(locstop) if(locstop)
return 0; return 0;
continue; continue;
@ -272,7 +276,7 @@ dexec(DwarfBuf *b, State *s, int locstop)
case 0x07: /* undefined */ case 0x07: /* undefined */
arg1 = dwarfget128(b); arg1 = dwarfget128(b);
if(trace) werrstr("r%ld = undef\n", arg1); if(trace) werrstr("r%ld = undef", arg1);
if(checkreg(s, arg1) < 0) if(checkreg(s, arg1) < 0)
return -1; return -1;
s->r[arg1].type = RuleUndef; s->r[arg1].type = RuleUndef;
@ -280,7 +284,7 @@ dexec(DwarfBuf *b, State *s, int locstop)
case 0x08: /* same value */ case 0x08: /* same value */
arg1 = dwarfget128(b); arg1 = dwarfget128(b);
if(trace) werrstr("r%ld = same\n", arg1); if(trace) werrstr("r%ld = same", arg1);
if(checkreg(s, arg1) < 0) if(checkreg(s, arg1) < 0)
return -1; return -1;
s->r[arg1].type = RuleSame; s->r[arg1].type = RuleSame;
@ -289,7 +293,7 @@ dexec(DwarfBuf *b, State *s, int locstop)
case 0x09: /* register */ case 0x09: /* register */
arg1 = dwarfget128(b); arg1 = dwarfget128(b);
arg2 = dwarfget128(b); arg2 = dwarfget128(b);
if(trace) werrstr("r%ld = r%ld\n", arg1, arg2); if(trace) werrstr("r%ld = r%ld", arg1, arg2);
if(checkreg(s, arg1) < 0 || checkreg(s, arg2) < 0) if(checkreg(s, arg1) < 0 || checkreg(s, arg2) < 0)
return -1; return -1;
s->r[arg1].type = RuleRegister; s->r[arg1].type = RuleRegister;
@ -298,7 +302,7 @@ dexec(DwarfBuf *b, State *s, int locstop)
case 0x0A: /* remember state */ case 0x0A: /* remember state */
e = malloc(s->nr*sizeof(e[0])); e = malloc(s->nr*sizeof(e[0]));
if(trace) werrstr("push\n"); if(trace) werrstr("push");
if(e == nil) if(e == nil)
return -1; return -1;
void *newstack = malloc(s->nstack*sizeof(s->stack[0])); void *newstack = malloc(s->nstack*sizeof(s->stack[0]));
@ -319,7 +323,7 @@ dexec(DwarfBuf *b, State *s, int locstop)
continue; continue;
case 0x0B: /* restore state */ case 0x0B: /* restore state */
if(trace) werrstr("pop\n"); if(trace) werrstr("pop");
if(s->nstack == 0){ if(s->nstack == 0){
werrstr("restore state underflow"); werrstr("restore state underflow");
return -1; return -1;
@ -334,7 +338,7 @@ dexec(DwarfBuf *b, State *s, int locstop)
arg1 = dwarfget128(b); arg1 = dwarfget128(b);
arg2 = dwarfget128(b); arg2 = dwarfget128(b);
defcfa: defcfa:
if(trace) werrstr("cfa %ld(r%ld)\n", arg2, arg1); if(trace) werrstr("cfa %ld(r%ld)", arg2, arg1);
if(checkreg(s, arg1) < 0) if(checkreg(s, arg1) < 0)
return -1; return -1;
s->cfa->type = RuleRegOff; s->cfa->type = RuleRegOff;
@ -344,7 +348,7 @@ dexec(DwarfBuf *b, State *s, int locstop)
case 0x0D: /* def cfa register */ case 0x0D: /* def cfa register */
arg1 = dwarfget128(b); arg1 = dwarfget128(b);
if(trace) werrstr("cfa reg r%ld\n", arg1); if(trace) werrstr("cfa reg r%ld", arg1);
if(s->cfa->type != RuleRegOff){ if(s->cfa->type != RuleRegOff){
werrstr("change CFA register but CFA not in register+offset form"); werrstr("change CFA register but CFA not in register+offset form");
return -1; return -1;
@ -357,7 +361,7 @@ dexec(DwarfBuf *b, State *s, int locstop)
case 0x0E: /* def cfa offset */ case 0x0E: /* def cfa offset */
arg1 = dwarfget128(b); arg1 = dwarfget128(b);
cfaoffset: cfaoffset:
if(trace) werrstr("cfa off %ld\n", arg1); if(trace) werrstr("cfa off %ld", arg1);
if(s->cfa->type != RuleRegOff){ if(s->cfa->type != RuleRegOff){
werrstr("change CFA offset but CFA not in register+offset form"); werrstr("change CFA offset but CFA not in register+offset form");
return -1; return -1;
@ -366,7 +370,7 @@ dexec(DwarfBuf *b, State *s, int locstop)
continue; continue;
case 0x0F: /* def cfa expression */ case 0x0F: /* def cfa expression */
if(trace) werrstr("cfa expr\n"); if(trace) werrstr("cfa expr");
s->cfa->type = RuleLocation; s->cfa->type = RuleLocation;
s->cfa->loc.len = dwarfget128(b); s->cfa->loc.len = dwarfget128(b);
s->cfa->loc.data = dwarfgetnref(b, s->cfa->loc.len); s->cfa->loc.data = dwarfgetnref(b, s->cfa->loc.len);
@ -374,7 +378,7 @@ dexec(DwarfBuf *b, State *s, int locstop)
case 0x10: /* def reg expression */ case 0x10: /* def reg expression */
arg1 = dwarfget128(b); arg1 = dwarfget128(b);
if(trace) werrstr("reg expr r%ld\n", arg1); if(trace) werrstr("reg expr r%ld", arg1);
if(checkreg(s, arg1) < 0) if(checkreg(s, arg1) < 0)
return -1; return -1;
s->r[arg1].type = RuleLocation; s->r[arg1].type = RuleLocation;
@ -397,11 +401,98 @@ dexec(DwarfBuf *b, State *s, int locstop)
goto cfaoffset; goto cfaoffset;
default: /* unknown */ default: /* unknown */
werrstr("unknown opcode 0x%ux in cfa program", c); werrstr("unknown opcode 0x%x in cfa program", c);
return -1; return -1;
} }
} }
/* not reached */ /* not reached */
} }
int dwarfcomputecfa(Dwarf *d, DwarfExpr *cfa, PROSSYM_REGISTERS registers, ulong *cfaLocation)
{
switch (cfa->type) {
case RuleRegOff:
*cfaLocation = registers->Registers[cfa->reg] + cfa->offset;
werrstr("cfa reg %d (%x) offset %x = %x", cfa->reg, (ulong)registers->Registers[cfa->reg], cfa->offset, cfaLocation);
break;
default:
werrstr("cfa->type %x", cfa->type);
return -1;
}
return 0;
}
int dwarfregunwind(Dwarf *d, ulong pc, ulong fde, DwarfExpr *cfa, PROSSYM_REGISTERS registers)
{
int i;
State s = { };
DwarfExpr initr[sizeof(registers->Registers) / sizeof(registers->Registers[0])] = { };
DwarfExpr r[sizeof(registers->Registers) / sizeof(registers->Registers[0])] = { };
DwarfExpr ra;
int nr = s.nr = sizeof(registers->Registers) / sizeof(registers->Registers[0]);
s.initr = initr;
s.r = r;
for (i = 0; i < sizeof(r) / sizeof(r[0]); i++) {
r[i].type = RuleRegister;
r[i].offset = registers->Registers[i];
r[i].reg = i;
}
int res = dwarfunwind(d, pc, cfa, &ra, initr, sizeof(initr) / sizeof(initr[0]));
if (res == -1) return -1;
ulong cfaLocation;
if (dwarfcomputecfa(d, cfa, registers, &cfaLocation) == -1)
return -1;
for (i = 0; i < nr; i++) {
switch (r[i].type) {
case RuleUndef:
werrstr("Undefined register slot %d", i);
assert(FALSE);
break;
case RuleSame:
break;
case RuleRegister:
registers->Registers[i] = registers->Registers[r[i].reg];
break;
case RuleRegOff: {
BOOLEAN success =
RosSymCallbacks.MemGetProc
(d->pe->fd,
&registers->Registers[i],
r[i].offset + registers->Registers[r[i].reg],
d->addrsize);
if (!success) return -1;
} break;
case RuleCfaOffset:
{
BOOLEAN success =
RosSymCallbacks.MemGetProc
(d->pe->fd,
&registers->Registers[i],
r[i].offset + cfaLocation,
d->addrsize);
werrstr("reg[%d] = %x: cfa offset (cfa %x, offset %x) -> @%x", i, (ulong)registers->Registers[i], cfaLocation, initr[i].offset, r[i].offset + cfaLocation);
if (!success) return -1;
} break;
default:
werrstr("We don't yet support cfa rule %d in slot %d", r[i].type, i);
assert(FALSE);
break;
}
}
ulong cfaSpace[4];
for (i = 0; i < sizeof(cfaSpace) / sizeof(cfaSpace[0]); i++) {
RosSymCallbacks.MemGetProc
(d->pe->fd, &cfaSpace[i], cfaLocation + (i * 4), d->addrsize);
}
werrstr("CFA(%x) [%08x, %08x, %08x, %08x]",
cfaLocation, cfaSpace[0], cfaSpace[1], cfaSpace[2], cfaSpace[3]);
return 0;
}

4
reactos/lib/rossym_new/dwarfget.c
View file

@ -139,7 +139,7 @@ dwarfgetaddr(DwarfBuf *b)
return dwarfget8(b); return dwarfget8(b);
default: default:
if(++nbad == 1) if(++nbad == 1)
werrstr("dwarf: unexpected address size %lud in dwarfgetaddr\n", b->addrsize); werrstr("dwarf: unexpected address size %lud in dwarfgetaddr", b->addrsize);
b->p = nil; b->p = nil;
return 0; return 0;
} }
@ -190,7 +190,7 @@ dwarfget128(DwarfBuf *b)
while(b->p<b->ep && *b->p&0x80) while(b->p<b->ep && *b->p&0x80)
b->p++; b->p++;
if(++nbad == 1) if(++nbad == 1)
werrstr("dwarf: overflow during parsing of uleb128 integer\n"); werrstr("dwarf: overflow during parsing of uleb128 integer");
return c; return c;
} }

1384
reactos/lib/rossym_new/dwarfinfo.c
View file

File diff suppressed because it is too large Load diff

4
reactos/lib/rossym_new/dwarfopen.c
View file

@ -31,7 +31,8 @@ dwarfopen(Pe *pe)
|| pe->loadsection(pe, ".debug_aranges", &d->aranges) < 0 || pe->loadsection(pe, ".debug_aranges", &d->aranges) < 0
|| pe->loadsection(pe, ".debug_line", &d->line) < 0 || pe->loadsection(pe, ".debug_line", &d->line) < 0
|| pe->loadsection(pe, ".debug_pubnames", &d->pubnames) < 0 || pe->loadsection(pe, ".debug_pubnames", &d->pubnames) < 0
|| pe->loadsection(pe, ".debug_info", &d->info) < 0) || pe->loadsection(pe, ".debug_info", &d->info) < 0
|| pe->loadsection(pe, ".debug_loc", &d->loc) < 0)
goto err; goto err;
pe->loadsection(pe, ".debug_frame", &d->frame); pe->loadsection(pe, ".debug_frame", &d->frame);
pe->loadsection(pe, ".debug_ranges", &d->ranges); pe->loadsection(pe, ".debug_ranges", &d->ranges);
@ -49,6 +50,7 @@ err:
free(d->ranges.data); free(d->ranges.data);
free(d->str.data); free(d->str.data);
free(d->info.data); free(d->info.data);
free(d->loc.data);
free(d); free(d);
return nil; return nil;
} }

696
reactos/lib/rossym_new/dwarfpc.c
View file

@ -27,359 +27,389 @@
enum enum
{ {
Isstmt = 1<<0, Isstmt = 1<<0,
BasicDwarfBlock = 1<<1, BasicDwarfBlock = 1<<1,
EndSequence = 1<<2, EndSequence = 1<<2,
PrologueEnd = 1<<3, PrologueEnd = 1<<3,
EpilogueBegin = 1<<4 EpilogueBegin = 1<<4
}; };
typedef struct State State; typedef struct State State;
struct State struct State
{ {
ulong addr; ulong addr;
ulong file; ulong file;
ulong line; ulong line;
ulong column; ulong column;
ulong flags; ulong flags;
ulong isa; ulong isa;
}; };
int int
dwarfpctoline(Dwarf *d, ulong pc, char **cdir, char **dir, char **file, char **function, ulong *line, ulong *mtime, ulong *length) dwarfpctoline(Dwarf *d, DwarfSym *proc, ulong pc, char **file, char **function, ulong *line)
{ {
uchar *prog, *opcount, *end, *dirs; char *cdir;
ulong off, unit, len, vers, x, start, lastline; uchar *prog, *opcount, *end, *dirs;
int i, first, firstline, op, a, l, quantum, isstmt, linebase, linerange, opcodebase, nf; ulong off, unit, len, vers, x, start, lastline;
char *files, *s; int i, first, firstline, op, a, l, quantum, isstmt, linebase, linerange, opcodebase, nf;
DwarfBuf b; char *files, *s;
DwarfSym sym; DwarfBuf b;
State emit, cur, reset; DwarfSym sym;
uchar **f, **newf; State emit, cur, reset;
char **f, **newf;
f = nil; f = nil;
memset(proc, 0, sizeof(*proc));
if(dwarfaddrtounit(d, pc, &unit) < 0 int runit = dwarfaddrtounit(d, pc, &unit);
|| dwarflookuptag(d, unit, TagCompileUnit, &sym) < 0) if (runit < 0)
return -1; return -1;
int rtag = dwarflookuptag(d, unit, TagCompileUnit, &sym);
if (rtag < 0)
return -1;
if(!sym.attrs.have.stmtlist){ if(!sym.attrs.have.stmtlist){
werrstr("no line mapping information for 0x%x", pc); werrstr("no line mapping information for 0x%x", pc);
return -1; return -1;
} }
off = sym.attrs.stmtlist; off = sym.attrs.stmtlist;
if(off >= d->line.len){ if(off >= d->line.len){
werrstr("bad stmtlist\n"); werrstr("bad stmtlist");
goto bad; goto bad;
}
if(trace) werrstr("unit 0x%x stmtlist 0x%x", unit, sym.attrs.stmtlist);
memset(&b, 0, sizeof b);
b.d = d;
b.p = d->line.data + off;
b.ep = b.p + d->line.len;
b.addrsize = sym.b.addrsize; /* should i get this from somewhere else? */
len = dwarfget4(&b);
if(b.p==nil || b.p+len > b.ep || b.p+len < b.p){
werrstr("bad len");
goto bad;
}
b.ep = b.p+len;
vers = dwarfget2(&b);
if(vers != 2){
werrstr("bad dwarf version 0x%x", vers);
return -1;
}
len = dwarfget4(&b);
if(b.p==nil || b.p+len > b.ep || b.p+len < b.p){
werrstr("another bad len");
goto bad;
}
prog = b.p+len;
quantum = dwarfget1(&b);
isstmt = dwarfget1(&b);
linebase = (schar)dwarfget1(&b);
linerange = (schar)dwarfget1(&b);
opcodebase = dwarfget1(&b);
opcount = b.p-1;
dwarfgetnref(&b, opcodebase-1);
if(b.p == nil){
werrstr("bad opcode chart");
goto bad;
}
/* just skip the files and dirs for now; we'll come back */
dirs = b.p;
while (b.p && *b.p)
dwarfgetstring(&b);
dwarfget1(&b);
files = (char*)b.p;
while(b.p!=nil && *b.p!=0){
dwarfgetstring(&b);
dwarfget128(&b);
dwarfget128(&b);
dwarfget128(&b);
}
dwarfget1(&b);
/* move on to the program */
if(b.p == nil || b.p > prog){
werrstr("bad header");
goto bad;
}
b.p = prog;
reset.addr = 0;
reset.file = 1;
reset.line = 1;
reset.column = 0;
reset.flags = isstmt ? Isstmt : 0;
reset.isa = 0;
cur = reset;
emit = reset;
nf = 0;
start = 0;
if(trace) werrstr("program @ %lu ... %.*H opbase = %d", b.p - d->line.data, b.ep-b.p, b.p, opcodebase);
first = 1;
while(b.p != nil){
firstline = 0;
op = dwarfget1(&b);
if(trace) werrstr("\tline %lu, addr 0x%x, op %d %.10H", cur.line, cur.addr, op, b.p);
if(op >= opcodebase){
a = (op - opcodebase) / linerange;
l = (op - opcodebase) % linerange + linebase;
cur.line += l;
cur.addr += a * quantum;
if(trace) werrstr(" +%d,%d", a, l);
emit:
if(first){
if(cur.addr > pc){
werrstr("found wrong line mapping 0x%x for pc 0x%x", cur.addr, pc);
/* This is an overzealous check. gcc can produce discontiguous ranges
and reorder statements, so it's possible for a future line to start
ahead of pc and still find a matching one. */
/*goto out;*/
firstline = 1;
}
first = 0;
start = cur.addr;
}
if(cur.addr > pc && !firstline)
break;
if(b.p == nil){
werrstr("buffer underflow in line mapping");
goto out;
}
emit = cur;
if(emit.flags & EndSequence){
werrstr("found wrong line mapping 0x%x-0x%x for pc 0x%x", start, cur.addr, pc);
goto out;
}
cur.flags &= ~(BasicDwarfBlock|PrologueEnd|EpilogueBegin);
}else{
switch(op){
case 0: /* extended op code */
if(trace) werrstr(" ext");
len = dwarfget128(&b);
end = b.p+len;
if(b.p == nil || end > b.ep || end < b.p || len < 1)
goto bad;
switch(dwarfget1(&b)){
case 1: /* end sequence */
if(trace) werrstr(" end");
cur.flags |= EndSequence;
goto emit;
case 2: /* set address */
cur.addr = dwarfgetaddr(&b);
if(trace) werrstr(" set pc 0x%x", cur.addr);
break;
case 3: /* define file */
newf = malloc(nf+1*sizeof(f[0]));
if (newf)
RtlMoveMemory(newf, f, nf*sizeof(f[0]));
if(newf == nil)
goto out;
free(f);
f = newf;
f[nf++] = s = dwarfgetstring(&b);
DPRINT1("str %s", s);
dwarfget128(&b);
dwarfget128(&b);
dwarfget128(&b);
if(trace) werrstr(" def file %s", s);
break;
}
if(b.p == nil || b.p > end)
goto bad;
b.p = end;
break;
case 1: /* emit */
if(trace) werrstr(" emit");
goto emit;
case 2: /* advance pc */
a = dwarfget128(&b);
if(trace) werrstr(" advance pc + %lu", a*quantum);
cur.addr += a * quantum;
break;
case 3: /* advance line */
l = dwarfget128s(&b);
if(trace) werrstr(" advance line + %ld", l);
cur.line += l;
break;
case 4: /* set file */
if(trace) werrstr(" set file");
cur.file = dwarfget128s(&b);
break;
case 5: /* set column */
if(trace) werrstr(" set column");
cur.column = dwarfget128(&b);
break;
case 6: /* negate stmt */
if(trace) werrstr(" negate stmt");
cur.flags ^= Isstmt;
break;
case 7: /* set basic block */
if(trace) werrstr(" set basic block");
cur.flags |= BasicDwarfBlock;
break;
case 8: /* const add pc */
a = (255 - opcodebase) / linerange * quantum;
if(trace) werrstr(" const add pc + %d", a);
cur.addr += a;
break;
case 9: /* fixed advance pc */
a = dwarfget2(&b);
if(trace) werrstr(" fixed advance pc + %d", a);
cur.addr += a;
break;
case 10: /* set prologue end */
if(trace) werrstr(" set prologue end");
cur.flags |= PrologueEnd;
break;
case 11: /* set epilogue begin */
if(trace) werrstr(" set epilogue begin");
cur.flags |= EpilogueBegin;
break;
case 12: /* set isa */
if(trace) werrstr(" set isa");
cur.isa = dwarfget128(&b);
break;
default: /* something new - skip it */
if(trace) werrstr(" unknown %d", opcount[op]);
for(i=0; i<opcount[op]; i++)
dwarfget128(&b);
break;
}
}
}
if(b.p == nil)
goto bad;
/* finally! the data we seek is in "emit" */
if(emit.file == 0){
werrstr("invalid file index in mapping data");
goto out;
}
if(line)
*line = emit.line;
/* skip over first emit.file-2 guys */
b.p = (uchar*)files;
for(i=emit.file-1; i > 0 && b.p!=nil && *b.p!=0; i--){
dwarfgetstring(&b);
dwarfget128(&b);
dwarfget128(&b);
dwarfget128(&b);
}
if(b.p == nil){
werrstr("problem parsing file data second time (cannot happen)");
goto bad;
}
if(*b.p == 0){
if(i >= nf){
werrstr("bad file index in mapping data");
goto bad;
}
b.p = (uchar*)f[i];
}
s = dwarfgetstring(&b);
*file = s;
i = dwarfget128(&b); /* directory */
x = dwarfget128(&b);
x = dwarfget128(&b);
/* fetch dir name */
cdir = sym.attrs.have.compdir ? sym.attrs.compdir : 0;
char *dwarfdir;
dwarfdir = nil;
b.p = dirs;
for (x = 1; b.p && *b.p; x++) {
dwarfdir = dwarfgetstring(&b);
if (x == i) break;
} }
if(trace) werrstr("unit 0x%x stmtlist 0x%x", unit, sym.attrs.stmtlist); if (!cdir && dwarfdir)
cdir = dwarfdir;
memset(&b, 0, sizeof b);
b.d = d; char *filefull = malloc(strlen(cdir) + strlen(*file) + 2);
b.p = d->line.data + off; strcpy(filefull, cdir);
b.ep = b.p + d->line.len; strcat(filefull, "/");
b.addrsize = sym.b.addrsize; /* should i get this from somewhere else? */ strcat(filefull, *file);
*file = filefull;
len = dwarfget4(&b);
if(b.p==nil || b.p+len > b.ep || b.p+len < b.p){ *function = nil;
werrstr("bad len\n"); lastline = 0;
goto bad;
} runit = dwarfaddrtounit(d, pc, &unit);
if (runit == 0) {
b.ep = b.p+len; DwarfSym compunit = { };
vers = dwarfget2(&b); int renum = dwarfenumunit(d, unit, &compunit);
if(vers != 2){ if (renum < 0)
werrstr("bad dwarf version 0x%x", vers); return -1;
return -1; renum = dwarfnextsymat(d, &compunit, proc);
} while (renum == 0) {
if (proc->attrs.tag == TagSubprogram &&
len = dwarfget4(&b); proc->attrs.have.name)
if(b.p==nil || b.p+len > b.ep || b.p+len < b.p){ {
werrstr("another bad len\n"); if (proc->attrs.lowpc <= pc && proc->attrs.highpc > pc) {
goto bad; *function = malloc(strlen(proc->attrs.name)+1);
} strcpy(*function, proc->attrs.name);
prog = b.p+len; goto done;
quantum = dwarfget1(&b);
isstmt = dwarfget1(&b);
linebase = (schar)dwarfget1(&b);
linerange = (schar)dwarfget1(&b);
opcodebase = dwarfget1(&b);
opcount = b.p-1;
dwarfgetnref(&b, opcodebase-1);
if(b.p == nil){
werrstr("bad opcode chart\n");
goto bad;
}
/* just skip the files and dirs for now; we'll come back */
dirs = b.p;
while (b.p && *b.p)
dwarfgetstring(&b);
dwarfget1(&b);
files = (char*)b.p;
while(b.p!=nil && *b.p!=0){
dwarfgetstring(&b);
dwarfget128(&b);
dwarfget128(&b);
dwarfget128(&b);
}
dwarfget1(&b);
/* move on to the program */
if(b.p == nil || b.p > prog){
werrstr("bad header\n");
goto bad;
}
b.p = prog;
reset.addr = 0;
reset.file = 1;
reset.line = 1;
reset.column = 0;
reset.flags = isstmt ? Isstmt : 0;
reset.isa = 0;
cur = reset;
emit = reset;
nf = 0;
start = 0;
if(trace) werrstr("program @ %lu ... %.*H opbase = %d\n", b.p - d->line.data, b.ep-b.p, b.p, opcodebase);
first = 1;
while(b.p != nil){
firstline = 0;
op = dwarfget1(&b);
if(trace) werrstr("\tline %lu, addr 0x%x, op %d %.10H", cur.line, cur.addr, op, b.p);
if(op >= opcodebase){
a = (op - opcodebase) / linerange;
l = (op - opcodebase) % linerange + linebase;
cur.line += l;
cur.addr += a * quantum;
if(trace) werrstr(" +%d,%d\n", a, l);
emit:
if(first){
if(cur.addr > pc){
werrstr("found wrong line mapping 0x%x for pc 0x%x", cur.addr, pc);
/* This is an overzealous check. gcc can produce discontiguous ranges
and reorder statements, so it's possible for a future line to start
ahead of pc and still find a matching one. */
/*goto out;*/
firstline = 1;
} }
first = 0;
start = cur.addr;
} }
if(cur.addr > pc && !firstline) renum = dwarfnextsym(d, proc);
break; }
if(b.p == nil){ }
werrstr("buffer underflow in line mapping");
goto out; // Next search by declaration
} runit = dwarfaddrtounit(d, pc, &unit);
emit = cur; if (runit == 0) {
if(emit.flags & EndSequence){ DwarfSym compunit = { };
werrstr("found wrong line mapping 0x%x-0x%x for pc 0x%x", start, cur.addr, pc); int renum = dwarfenumunit(d, unit, &compunit);
goto out; if (renum < 0)
} return -1;
cur.flags &= ~(BasicDwarfBlock|PrologueEnd|EpilogueBegin); renum = dwarfnextsymat(d, &compunit, proc);
}else{ while (renum == 0) {
switch(op){ if (proc->attrs.tag == TagSubprogram &&
case 0: /* extended op code */ proc->attrs.have.name &&
if(trace) werrstr(" ext"); proc->attrs.declfile == emit.file)
len = dwarfget128(&b); {
end = b.p+len; if (proc->attrs.declline <= *line &&
if(b.p == nil || end > b.ep || end < b.p || len < 1) proc->attrs.declline > lastline) {
goto bad; free(*function);
switch(dwarfget1(&b)){ *function = malloc(strlen(proc->attrs.name)+1);
case 1: /* end sequence */ strcpy(*function, proc->attrs.name);
if(trace) werrstr(" end\n"); goto done;
cur.flags |= EndSequence;
goto emit;
case 2: /* set address */
cur.addr = dwarfgetaddr(&b);
if(trace) werrstr(" set pc 0x%x\n", cur.addr);
break;
case 3: /* define file */
newf = malloc(nf+1*sizeof(f[0]));
if (newf)
RtlMoveMemory(newf, f, nf*sizeof(f[0]));
if(newf == nil)
goto out;
f[nf++] = b.p;
s = dwarfgetstring(&b);
dwarfget128(&b);
dwarfget128(&b);
dwarfget128(&b);
if(trace) werrstr(" def file %s\n", s);
break;
} }
if(b.p == nil || b.p > end) lastline = proc->attrs.declline;
goto bad;
b.p = end;
break;
case 1: /* emit */
if(trace) werrstr(" emit\n");
goto emit;
case 2: /* advance pc */
a = dwarfget128(&b);
if(trace) werrstr(" advance pc + %lu\n", a*quantum);
cur.addr += a * quantum;
break;
case 3: /* advance line */
l = dwarfget128s(&b);
if(trace) werrstr(" advance line + %ld\n", l);
cur.line += l;
break;
case 4: /* set file */
if(trace) werrstr(" set file\n");
cur.file = dwarfget128s(&b);
break;
case 5: /* set column */
if(trace) werrstr(" set column\n");
cur.column = dwarfget128(&b);
break;
case 6: /* negate stmt */
if(trace) werrstr(" negate stmt\n");
cur.flags ^= Isstmt;
break;
case 7: /* set basic block */
if(trace) werrstr(" set basic block\n");
cur.flags |= BasicDwarfBlock;
break;
case 8: /* const add pc */
a = (255 - opcodebase) / linerange * quantum;
if(trace) werrstr(" const add pc + %d\n", a);
cur.addr += a;
break;
case 9: /* fixed advance pc */
a = dwarfget2(&b);
if(trace) werrstr(" fixed advance pc + %d\n", a);
cur.addr += a;
break;
case 10: /* set prologue end */
if(trace) werrstr(" set prologue end\n");
cur.flags |= PrologueEnd;
break;
case 11: /* set epilogue begin */
if(trace) werrstr(" set epilogue begin\n");
cur.flags |= EpilogueBegin;
break;
case 12: /* set isa */
if(trace) werrstr(" set isa\n");
cur.isa = dwarfget128(&b);
break;
default: /* something new - skip it */
if(trace) werrstr(" unknown %d\n", opcount[op]);
for(i=0; i<opcount[op]; i++)
dwarfget128(&b);
break;
} }
} renum = dwarfnextsym(d, proc);
} }
if(b.p == nil) }
goto bad;
/* finally! the data we seek is in "emit" */
if(emit.file == 0){
werrstr("invalid file index in mapping data");
goto out;
}
if(line)
*line = emit.line;
/* skip over first emit.file-2 guys */
b.p = (uchar*)files;
for(i=emit.file-1; i > 0 && b.p!=nil && *b.p!=0; i--){
dwarfgetstring(&b);
dwarfget128(&b);
dwarfget128(&b);
dwarfget128(&b);
}
if(b.p == nil){
werrstr("problem parsing file data second time (cannot happen)");
goto bad;
}
if(*b.p == 0){
if(i >= nf){
werrstr("bad file index in mapping data");
goto bad;
}
b.p = f[i];
}
s = dwarfgetstring(&b);
if(file)
*file = s;
i = dwarfget128(&b); /* directory */
x = dwarfget128(&b);
if(mtime)
*mtime = x;
x = dwarfget128(&b);
if(length)
*length = x;
/* fetch dir name */
if(cdir)
*cdir = sym.attrs.compdir;
if(dir){
*dir = nil;
b.p = dirs;
for (x = 1; b.p && *b.p; x++)
if (x == i) {
*dir = dwarfgetstring(&b);
break;
}
}
*function = nil;
lastline = 0;
#if 0
if (dwarfenumunit(d, unit, &proc) >= 0) {
dwarfnextsymat(d, &proc, 0);
while (dwarfnextsymat(d, &proc, 1) == 1) {
if (proc.attrs.tag == TagSubprogram &&
proc.attrs.have.name &&
proc.attrs.declfile == emit.file &&
proc.attrs.declline <= *line &&
proc.attrs.declline > lastline) {
lastline = proc.attrs.declline;
free(*function);
*function = malloc(strlen(proc.attrs.name)+1);
strcpy(*function, proc.attrs.name);
}
}
}
#elif 1
ulong lastaddr = 0;
*function = NULL;
for (i = 0; i < d->pe->nsymbols; i++) {
if (d->pe->symtab[i].address > lastaddr &&
d->pe->symtab[i].address <= pc - d->pe->imagebase &&
d->pe->symtab[i].address < d->pe->imagesize) {
lastaddr = d->pe->symtab[i].address;
*function = d->pe->symtab[i].name;
}
}
#else
// *sigh* we get unrelocated low_pc and high_pc because the dwarf symbols
// are not 'loaded' in the PE sense.
if (dwarflookupfn(d, unit, pc, &proc) >= 0) {
*function = malloc(strlen(proc.attrs.name)+1);
strcpy(*function, proc.attrs.name);
}
#endif
/* free at last, free at last */
free(f);
return 0;
/* free at last, free at last */
done:
free(f);
return 0;
bad: bad:
werrstr("corrupted line mapping for 0x%x", pc); werrstr("corrupted line mapping for 0x%x", pc);
out: out:
free(f); free(f);
return -1; return -1;
} }
VOID RosSymFreeInfo(PROSSYM_LINEINFO LineInfo)
{
int i;
free(LineInfo->FileName);
LineInfo->FileName = NULL;
free(LineInfo->FunctionName);
LineInfo->FunctionName = NULL;
for (i = 0; i < sizeof(LineInfo->Parameters)/sizeof(LineInfo->Parameters[0]); i++)
free(LineInfo->Parameters[i].ValueName);
}

103
reactos/lib/rossym_new/find.c
View file

@ -47,40 +47,85 @@
#include "pe.h" #include "pe.h"
BOOLEAN BOOLEAN
RosSymGetAddressInformation(PROSSYM_INFO RosSymInfo, RosSymGetAddressInformation
ULONG_PTR RelativeAddress, (PROSSYM_INFO RosSymInfo,
ULONG *LineNumber, ULONG_PTR RelativeAddress,
char *FileName, PROSSYM_LINEINFO RosSymLineInfo)
char *FunctionName)
{ {
char *cdir, *dir, *file, *function; ROSSYM_REGISTERS registers;
ulong line, mtime, length; DwarfParam params[sizeof(RosSymLineInfo->Parameters)/sizeof(RosSymLineInfo->Parameters[0])];
DwarfSym proc = { };
int i;
int res = dwarfpctoline int res = dwarfpctoline
(RosSymInfo, (RosSymInfo,
&proc,
RelativeAddress + RosSymInfo->pe->imagebase, RelativeAddress + RosSymInfo->pe->imagebase,
&cdir, &RosSymLineInfo->FileName,
&dir, &RosSymLineInfo->FunctionName,
&file, &RosSymLineInfo->LineNumber);
&function, if (res == -1) {
&line, werrstr("Could not get basic function info");
&mtime,
&length);
if (res != -1) {
*LineNumber = line;
FileName[0] = 0;
if (dir) {
strcpy(FileName, dir);
strcat(FileName, "/");
}
if (file)
strcat(FileName, file);
FunctionName[0] = 0;
if (function)
strcpy(FunctionName, function);
return TRUE;
} else {
return FALSE; return FALSE;
} }
if (!(RosSymLineInfo->Flags & ROSSYM_LINEINFO_HAS_REGISTERS))
return TRUE;
registers = RosSymLineInfo->Registers;
DwarfExpr cfa = { };
ulong cfaLocation;
if (dwarfregunwind
(RosSymInfo,
RelativeAddress + RosSymInfo->pe->imagebase,
proc.attrs.framebase.c,
&cfa,
&registers) == -1) {
werrstr("Can't get cfa location for %s", RosSymLineInfo->FunctionName);
return TRUE;
}
res = dwarfgetparams
(RosSymInfo,
&proc,
RelativeAddress + RosSymInfo->pe->imagebase,
sizeof(params)/sizeof(params[0]),
params);
if (res == -1) {
werrstr("%s: could not get params at all", RosSymLineInfo->FunctionName);
RosSymLineInfo->NumParams = 0;
return TRUE;
}
werrstr("%s: res %d", RosSymLineInfo->FunctionName, res);
RosSymLineInfo->NumParams = res;
res = dwarfcomputecfa(RosSymInfo, &cfa, &registers, &cfaLocation);
if (res == -1) {
werrstr("%s: could not get our own cfa", RosSymLineInfo->FunctionName);
return TRUE;
}
for (i = 0; i < RosSymLineInfo->NumParams; i++) {
werrstr("Getting arg %s, unit %x, type %x",
params[i].name, params[i].unit, params[i].type);
res = dwarfargvalue
(RosSymInfo,
&proc,
RelativeAddress + RosSymInfo->pe->imagebase,
cfaLocation,
&registers,
&params[i]);
if (res == -1) { RosSymLineInfo->NumParams = i; return TRUE; }
werrstr("%s: %x", params[i].name, params[i].value);
RosSymLineInfo->Parameters[i].ValueName = malloc(strlen(params[i].name)+1);
strcpy(RosSymLineInfo->Parameters[i].ValueName, params[i].name);
free(params[i].name);
RosSymLineInfo->Parameters[i].Value = params[i].value;
}
return TRUE;
} }
/* EOF */ /* EOF */

251
reactos/lib/rossym_new/fromfile.c
View file

@ -20,191 +20,144 @@
#define NDEBUG #define NDEBUG
#include <debug.h> #include <debug.h>
#define SYMBOL_SIZE 18
extern NTSTATUS RosSymStatus; extern NTSTATUS RosSymStatus;
BOOLEAN BOOLEAN
RosSymCreateFromFile(PVOID FileContext, PROSSYM_INFO *RosSymInfo) RosSymCreateFromFile(PVOID FileContext, PROSSYM_INFO *RosSymInfo)
{ {
IMAGE_DOS_HEADER DosHeader; IMAGE_DOS_HEADER DosHeader;
IMAGE_NT_HEADERS NtHeaders; IMAGE_NT_HEADERS NtHeaders;
PIMAGE_SECTION_HEADER SectionHeaders; PIMAGE_SECTION_HEADER SectionHeaders;
unsigned SectionIndex; unsigned SectionIndex;
unsigned SymbolTable, NumSymbols; unsigned SymbolTable, NumSymbols;
/* Load DOS header */ /* Load DOS header */
if (! RosSymSeekFile(FileContext, 0)) if (! RosSymSeekFile(FileContext, 0))
{ {
DPRINT1("Could not rewind file\n"); werrstr("Could not rewind file\n");
return FALSE; return FALSE;
}
if (! RosSymReadFile(FileContext, &DosHeader, sizeof(IMAGE_DOS_HEADER)))
{
DPRINT1("Failed to read DOS header %x\n", RosSymStatus);
return FALSE;
} }
if (! ROSSYM_IS_VALID_DOS_HEADER(&DosHeader)) if (! RosSymReadFile(FileContext, &DosHeader, sizeof(IMAGE_DOS_HEADER)))
{ {
DPRINT1("Image doesn't have a valid DOS header\n"); werrstr("Failed to read DOS header %x\n", RosSymStatus);
return FALSE; return FALSE;
}
if (! ROSSYM_IS_VALID_DOS_HEADER(&DosHeader))
{
werrstr("Image doesn't have a valid DOS header\n");
return FALSE;
} }
/* Load NT headers */ /* Load NT headers */
if (! RosSymSeekFile(FileContext, DosHeader.e_lfanew)) if (! RosSymSeekFile(FileContext, DosHeader.e_lfanew))
{ {
DPRINT1("Failed seeking to NT headers\n"); werrstr("Failed seeking to NT headers\n");
return FALSE; return FALSE;
} }
if (! RosSymReadFile(FileContext, &NtHeaders, sizeof(IMAGE_NT_HEADERS))) if (! RosSymReadFile(FileContext, &NtHeaders, sizeof(IMAGE_NT_HEADERS)))
{ {
DPRINT1("Failed to read NT headers\n"); werrstr("Failed to read NT headers\n");
return FALSE; return FALSE;
} }
if (! ROSSYM_IS_VALID_NT_HEADERS(&NtHeaders)) if (! ROSSYM_IS_VALID_NT_HEADERS(&NtHeaders))
{ {
DPRINT1("Image doesn't have a valid PE header\n"); werrstr("Image doesn't have a valid PE header\n");
return FALSE; return FALSE;
} }
SymbolTable = NtHeaders.FileHeader.PointerToSymbolTable; SymbolTable = NtHeaders.FileHeader.PointerToSymbolTable;
NumSymbols = NtHeaders.FileHeader.NumberOfSymbols; NumSymbols = NtHeaders.FileHeader.NumberOfSymbols;
if (!NumSymbols) if (!NumSymbols)
{ {
DPRINT1("Image doesn't have debug symbols\n"); werrstr("Image doesn't have debug symbols\n");
return FALSE; return FALSE;
} }
DPRINT("SymbolTable %x NumSymbols %x\n", SymbolTable, NumSymbols); DPRINT("SymbolTable %x NumSymbols %x\n", SymbolTable, NumSymbols);
/* Load section headers */ /* Load section headers */
if (! RosSymSeekFile(FileContext, (char *) IMAGE_FIRST_SECTION(&NtHeaders) - if (! RosSymSeekFile(FileContext, (char *) IMAGE_FIRST_SECTION(&NtHeaders) -
(char *) &NtHeaders + DosHeader.e_lfanew)) (char *) &NtHeaders + DosHeader.e_lfanew))
{ {
DPRINT1("Failed seeking to section headers\n"); werrstr("Failed seeking to section headers\n");
return FALSE; return FALSE;
} }
DPRINT("Alloc section headers\n"); DPRINT("Alloc section headers\n");
SectionHeaders = RosSymAllocMem(NtHeaders.FileHeader.NumberOfSections SectionHeaders = RosSymAllocMem(NtHeaders.FileHeader.NumberOfSections
* sizeof(IMAGE_SECTION_HEADER)); * sizeof(IMAGE_SECTION_HEADER));
if (NULL == SectionHeaders) if (NULL == SectionHeaders)
{ {
DPRINT1("Failed to allocate memory for %u section headers\n", werrstr("Failed to allocate memory for %u section headers\n",
NtHeaders.FileHeader.NumberOfSections); NtHeaders.FileHeader.NumberOfSections);
return FALSE; return FALSE;
} }
if (! RosSymReadFile(FileContext, SectionHeaders, if (! RosSymReadFile(FileContext, SectionHeaders,
NtHeaders.FileHeader.NumberOfSections NtHeaders.FileHeader.NumberOfSections
* sizeof(IMAGE_SECTION_HEADER))) * sizeof(IMAGE_SECTION_HEADER)))
{ {
RosSymFreeMem(SectionHeaders); RosSymFreeMem(SectionHeaders);
DPRINT1("Failed to read section headers\n"); werrstr("Failed to read section headers\n");
return FALSE; return FALSE;
} }
// Convert names to ANSI_STRINGs // Convert names to ANSI_STRINGs
for (SectionIndex = 0; SectionIndex < NtHeaders.FileHeader.NumberOfSections; for (SectionIndex = 0; SectionIndex < NtHeaders.FileHeader.NumberOfSections;
SectionIndex++) SectionIndex++)
{ {
ANSI_STRING astr; ANSI_STRING astr;
if (SectionHeaders[SectionIndex].Name[0] != '/') { if (SectionHeaders[SectionIndex].Name[0] != '/') {
DPRINT("Short name string %d, %s\n", SectionIndex, SectionHeaders[SectionIndex].Name); DPRINT("Short name string %d, %s\n", SectionIndex, SectionHeaders[SectionIndex].Name);
astr.Buffer = RosSymAllocMem(IMAGE_SIZEOF_SHORT_NAME); astr.Buffer = RosSymAllocMem(IMAGE_SIZEOF_SHORT_NAME);
memcpy(astr.Buffer, SectionHeaders[SectionIndex].Name, IMAGE_SIZEOF_SHORT_NAME); memcpy(astr.Buffer, SectionHeaders[SectionIndex].Name, IMAGE_SIZEOF_SHORT_NAME);
astr.MaximumLength = IMAGE_SIZEOF_SHORT_NAME; astr.MaximumLength = IMAGE_SIZEOF_SHORT_NAME;
astr.Length = GetStrnlen(astr.Buffer, IMAGE_SIZEOF_SHORT_NAME); astr.Length = GetStrnlen(astr.Buffer, IMAGE_SIZEOF_SHORT_NAME);
} else { } else {
UNICODE_STRING intConv; UNICODE_STRING intConv;
NTSTATUS Status; NTSTATUS Status;
ULONG StringOffset; ULONG StringOffset;
Status = RtlCreateUnicodeStringFromAsciiz(&intConv, (PCSZ)SectionHeaders[SectionIndex].Name + 1); Status = RtlCreateUnicodeStringFromAsciiz(&intConv, (PCSZ)SectionHeaders[SectionIndex].Name + 1);
if (!NT_SUCCESS(Status)) goto freeall; if (!NT_SUCCESS(Status)) goto freeall;
Status = RtlUnicodeStringToInteger(&intConv, 10, &StringOffset); Status = RtlUnicodeStringToInteger(&intConv, 10, &StringOffset);
RtlFreeUnicodeString(&intConv); RtlFreeUnicodeString(&intConv);
if (!NT_SUCCESS(Status)) goto freeall; if (!NT_SUCCESS(Status)) goto freeall;
if (!RosSymSeekFile(FileContext, SymbolTable + NumSymbols * SYMBOL_SIZE + StringOffset)) if (!RosSymSeekFile(FileContext, SymbolTable + NumSymbols * SYMBOL_SIZE + StringOffset))
goto freeall; goto freeall;
astr.Buffer = RosSymAllocMem(MAXIMUM_DWARF_NAME_SIZE); astr.Buffer = RosSymAllocMem(MAXIMUM_DWARF_NAME_SIZE);
if (!RosSymReadFile(FileContext, astr.Buffer, MAXIMUM_DWARF_NAME_SIZE)) if (!RosSymReadFile(FileContext, astr.Buffer, MAXIMUM_DWARF_NAME_SIZE))
goto freeall; goto freeall;
astr.Length = GetStrnlen(astr.Buffer, MAXIMUM_DWARF_NAME_SIZE); astr.Length = GetStrnlen(astr.Buffer, MAXIMUM_DWARF_NAME_SIZE);
astr.MaximumLength = MAXIMUM_DWARF_NAME_SIZE; astr.MaximumLength = MAXIMUM_DWARF_NAME_SIZE;
DPRINT("Long name %d, %s\n", SectionIndex, astr.Buffer); DPRINT("Long name %d, %s\n", SectionIndex, astr.Buffer);
} }
*ANSI_NAME_STRING(&SectionHeaders[SectionIndex]) = astr; *ANSI_NAME_STRING(&SectionHeaders[SectionIndex]) = astr;
} }
DPRINT("Done with sections\n"); DPRINT("Done with sections\n");
Pe *pe = RosSymAllocMem(sizeof(*pe)); Pe *pe = RosSymAllocMem(sizeof(*pe));
pe->fd = FileContext; pe->fd = FileContext;
pe->e2 = peget2; pe->e2 = peget2;
pe->e4 = peget4; pe->e4 = peget4;
pe->e8 = peget8; pe->e8 = peget8;
pe->nsections = NtHeaders.FileHeader.NumberOfSections; pe->nsections = NtHeaders.FileHeader.NumberOfSections;
pe->sect = SectionHeaders; pe->sect = SectionHeaders;
pe->nsymbols = NtHeaders.FileHeader.NumberOfSymbols; pe->imagebase = pe->loadbase = NtHeaders.OptionalHeader.ImageBase;
pe->symtab = malloc(pe->nsymbols * sizeof(CoffSymbol)); pe->imagesize = NtHeaders.OptionalHeader.SizeOfImage;
SYMENT SymbolData; pe->loadsection = loaddisksection;
int i, j; *RosSymInfo = dwarfopen(pe);
DPRINT("Getting symbol data\n");
ASSERT(sizeof(SymbolData) == 18);
for (i = 0, j = 0; i < pe->nsymbols; i++) {
if (!RosSymSeekFile
(FileContext,
NtHeaders.FileHeader.PointerToSymbolTable + i * sizeof(SymbolData)))
goto freeall;
if (!RosSymReadFile(FileContext, &SymbolData, sizeof(SymbolData)))
goto freeall;
if ((SymbolData.e_scnum < 1) ||
(SymbolData.e_sclass != C_EXT &&
SymbolData.e_sclass != C_STAT))
continue;
int section = SymbolData.e_scnum - 1;
if (SymbolData.e.e.e_zeroes) {
pe->symtab[j].name = malloc(sizeof(SymbolData.e.e_name)+1);
memcpy(pe->symtab[j].name, SymbolData.e.e_name, sizeof(SymbolData.e.e_name));
pe->symtab[j].name[sizeof(SymbolData.e.e_name)] = 0;
} else {
if (!RosSymSeekFile
(FileContext,
NtHeaders.FileHeader.PointerToSymbolTable +
(NtHeaders.FileHeader.NumberOfSymbols * 18) +
SymbolData.e.e.e_offset))
goto freeall;
pe->symtab[j].name = malloc(MAXIMUM_COFF_SYMBOL_LENGTH+1);
pe->symtab[j].name[MAXIMUM_COFF_SYMBOL_LENGTH] = 0;
// It's possible that we've got a string just at the end of the file
// we'll skip that symbol if needed
if (!RosSymReadFile(FileContext, pe->symtab[j].name, MAXIMUM_COFF_SYMBOL_LENGTH)) {
free(pe->symtab[j].name);
continue;
}
}
if (pe->symtab[j].name[0] == '.') {
free(pe->symtab[j].name);
continue;
}
pe->symtab[j].address = pe->sect[section].VirtualAddress + SymbolData.e_value;
j++;
}
DPRINT("%d symbols\n", j);
pe->nsymbols = j;
pe->imagebase = pe->loadbase = NtHeaders.OptionalHeader.ImageBase;
pe->imagesize = NtHeaders.OptionalHeader.SizeOfImage;
pe->loadsection = loaddisksection;
DPRINT("do dwarfopen\n");
*RosSymInfo = dwarfopen(pe);
DPRINT("done %x\n", *RosSymInfo);
return TRUE; return TRUE;
freeall: freeall:
for (SectionIndex = 0; SectionIndex < NtHeaders.FileHeader.NumberOfSections; for (SectionIndex = 0; SectionIndex < NtHeaders.FileHeader.NumberOfSections;
SectionIndex++) SectionIndex++)
RtlFreeAnsiString(ANSI_NAME_STRING(&SectionHeaders[SectionIndex])); RtlFreeAnsiString(ANSI_NAME_STRING(&SectionHeaders[SectionIndex]));
RosSymFreeMem(SectionHeaders); RosSymFreeMem(SectionHeaders);
return FALSE; return FALSE;
} }
/* EOF */ /* EOF */

10
reactos/lib/rossym_new/initum.c
View file

@ -13,6 +13,7 @@
#include "rossympriv.h" #include "rossympriv.h"
#define NTOS_MODE_USER #define NTOS_MODE_USER
#include <ndk/ntndk.h> #include <ndk/ntndk.h>
#include <pseh/pseh.h>
#define NDEBUG #define NDEBUG
#include <debug.h> #include <debug.h>
@ -29,6 +30,12 @@ RosSymFreeMemUM(PVOID Area)
RtlFreeHeap(RtlGetProcessHeap(), 0, Area); RtlFreeHeap(RtlGetProcessHeap(), 0, Area);
} }
static BOOLEAN
RosSymGetMemUM(ULONG_PTR *Target, PVOID SourceMem, ULONG Size)
{
return FALSE;
}
VOID VOID
RosSymInitUserMode(VOID) RosSymInitUserMode(VOID)
{ {
@ -37,7 +44,8 @@ RosSymInitUserMode(VOID)
RosSymAllocMemUM, RosSymAllocMemUM,
RosSymFreeMemUM, RosSymFreeMemUM,
RosSymZwReadFile, RosSymZwReadFile,
RosSymZwSeekFile RosSymZwSeekFile,
RosSymGetMemUM
}; };
RosSymInit(&KmCallbacks); RosSymInit(&KmCallbacks);

4
reactos/lib/rossym_new/pe.c
View file

@ -111,10 +111,6 @@ void pefree(Pe *pe) {
for (i = 0; i < pe->nsections; i++) { for (i = 0; i < pe->nsections; i++) {
RtlFreeAnsiString(ANSI_NAME_STRING(&pe->sect[i])); RtlFreeAnsiString(ANSI_NAME_STRING(&pe->sect[i]));
} }
for (i = 0; i < pe->nsymbols; i++) {
free(pe->symtab[i].name);
}
free(pe->symtab);
free(pe->sect); free(pe->sect);
free(pe); free(pe);
} }

30
reactos/lib/rossym_new/pe.h
View file

@ -6,49 +6,19 @@
struct DwarfBlock; struct DwarfBlock;
typedef struct _IMAGE_SECTION_HEADER PeSect; typedef struct _IMAGE_SECTION_HEADER PeSect;
typedef struct _CoffSymbol {
ulong address;
char *name;
} CoffSymbol;
typedef struct _Pe { typedef struct _Pe {
void *fd; void *fd;
u16int (*e2)(const unsigned char *data); u16int (*e2)(const unsigned char *data);
u32int (*e4)(const unsigned char *data); u32int (*e4)(const unsigned char *data);
u64int (*e8)(const unsigned char *data); u64int (*e8)(const unsigned char *data);
ulong imagebase, imagesize, loadbase; ulong imagebase, imagesize, loadbase;
ulong nsymbols;
CoffSymbol *symtab;
int (*loadsection)(struct _Pe *pe, char *name, struct DwarfBlock *b); int (*loadsection)(struct _Pe *pe, char *name, struct DwarfBlock *b);
int nsections; int nsections;
struct _IMAGE_SECTION_HEADER *sect; struct _IMAGE_SECTION_HEADER *sect;
} Pe; } Pe;
#define E_SYMNMLEN 8
#include <pshpack1.h>
typedef struct {
union {
char e_name[E_SYMNMLEN];
struct {
unsigned long e_zeroes;
unsigned long e_offset;
} e;
} e;
unsigned long e_value;
short e_scnum;
unsigned short e_type;
unsigned char e_sclass;
unsigned char e_numaux;
} SYMENT, *PSYMENT;
#include <poppack.h>
#define C_EXT 2
#define C_STAT 3
#define DT_FCN 0x40
Pe *peopen(const char *name); Pe *peopen(const char *name);
int loaddisksection(struct _Pe *pe, char *name, struct DwarfBlock *b); int loaddisksection(struct _Pe *pe, char *name, struct DwarfBlock *b);
int loadmemsection(struct _Pe *pe, char *name, struct DwarfBlock *b);
u16int peget2(const unsigned char *ptr); u16int peget2(const unsigned char *ptr);
u32int peget4(const unsigned char *ptr); u32int peget4(const unsigned char *ptr);
u64int peget8(const unsigned char *ptr); u64int peget8(const unsigned char *ptr);

6
reactos/lib/rossym_new/rossympriv.h
View file

@ -9,19 +9,19 @@
#pragma once #pragma once
#define HIGHBIT 0x80000000
extern ROSSYM_CALLBACKS RosSymCallbacks; extern ROSSYM_CALLBACKS RosSymCallbacks;
#define RosSymAllocMem(Size) (*RosSymCallbacks.AllocMemProc)(Size) #define RosSymAllocMem(Size) (*RosSymCallbacks.AllocMemProc)(Size)
#define RosSymFreeMem(Area) (*RosSymCallbacks.FreeMemProc)(Area) #define RosSymFreeMem(Area) (*RosSymCallbacks.FreeMemProc)(Area)
#define RosSymReadFile(FileContext, Buffer, Size) (*RosSymCallbacks.ReadFileProc)((FileContext), (Buffer), (Size)) #define RosSymReadFile(FileContext, Buffer, Size) (*RosSymCallbacks.ReadFileProc)((FileContext), (Buffer), (Size))
#define RosSymSeekFile(FileContext, Position) (*RosSymCallbacks.SeekFileProc)((FileContext), (Position)) #define RosSymSeekFile(FileContext, Position) (*RosSymCallbacks.SeekFileProc)((FileContext), (Position))
#define RosSymGetMem(TargetAddress, Address, Size) (*RosSymCallbacks.MemGetProc)((TargetAddress), (Address), (Size))
extern BOOLEAN RosSymZwReadFile(PVOID FileContext, PVOID Buffer, ULONG Size); extern BOOLEAN RosSymZwReadFile(PVOID FileContext, PVOID Buffer, ULONG Size);
extern BOOLEAN RosSymZwSeekFile(PVOID FileContext, ULONG_PTR Position); extern BOOLEAN RosSymZwSeekFile(PVOID FileContext, ULONG_PTR Position);
extern BOOLEAN RosSymIoReadFile(PVOID FileContext, PVOID Buffer, ULONG Size);
extern BOOLEAN RosSymIoSeekFile(PVOID FileContext, ULONG_PTR Position);
#define ROSSYM_IS_VALID_DOS_HEADER(DosHeader) (IMAGE_DOS_SIGNATURE == (DosHeader)->e_magic \ #define ROSSYM_IS_VALID_DOS_HEADER(DosHeader) (IMAGE_DOS_SIGNATURE == (DosHeader)->e_magic \
&& 0L != (DosHeader)->e_lfanew) && 0L != (DosHeader)->e_lfanew)
#define ROSSYM_IS_VALID_NT_HEADERS(NtHeaders) (IMAGE_NT_SIGNATURE == (NtHeaders)->Signature \ #define ROSSYM_IS_VALID_NT_HEADERS(NtHeaders) (IMAGE_NT_SIGNATURE == (NtHeaders)->Signature \

8
reactos/ntoskrnl/include/internal/kd.h
View file

@ -75,15 +75,21 @@ KdbSymProcessSymbols(
BOOLEAN BOOLEAN
KdbSymPrintAddress( KdbSymPrintAddress(
IN PVOID Address); IN PVOID Address,
IN PKTRAP_FRAME Context
);
NTSTATUS NTSTATUS
KdbSymGetAddressInformation( KdbSymGetAddressInformation(
IN PROSSYM_INFO RosSymInfo, IN PROSSYM_INFO RosSymInfo,
IN ULONG_PTR RelativeAddress, IN ULONG_PTR RelativeAddress,
#ifdef __ROS_CMAKE__
IN PROSSYM_LINEINFO RosSymLineInfo
#else
OUT PULONG LineNumber OPTIONAL, OUT PULONG LineNumber OPTIONAL,
OUT PCH FileName OPTIONAL, OUT PCH FileName OPTIONAL,
OUT PCH FunctionName OPTIONAL OUT PCH FunctionName OPTIONAL
#endif
); );
#endif #endif

2
reactos/ntoskrnl/kdbg/i386/i386-dis.c
View file

@ -78,7 +78,7 @@ KdbpMemoryError(int Status, unsigned int Addr,
static void static void
KdbpPrintAddressInCode(unsigned int Addr, struct disassemble_info * Ignored) KdbpPrintAddressInCode(unsigned int Addr, struct disassemble_info * Ignored)
{ {
if (!KdbSymPrintAddress((void*)Addr)) if (!KdbSymPrintAddress((void*)Addr, NULL))
{ {
DbgPrint("<%08x>", Addr); DbgPrint("<%08x>", Addr);
} }

20
reactos/ntoskrnl/kdbg/kdb_cli.c
View file

@ -595,7 +595,7 @@ KdbpCmdDisassembleX(
while (Count > 0) while (Count > 0)
{ {
if (!KdbSymPrintAddress((PVOID)Address)) if (!KdbSymPrintAddress((PVOID)Address, NULL))
KdbpPrint("<%x>:", Address); KdbpPrint("<%x>:", Address);
else else
KdbpPrint(":"); KdbpPrint(":");
@ -621,7 +621,7 @@ KdbpCmdDisassembleX(
/* Disassemble */ /* Disassemble */
while (Count-- > 0) while (Count-- > 0)
{ {
if (!KdbSymPrintAddress((PVOID)Address)) if (!KdbSymPrintAddress((PVOID)Address, NULL))
KdbpPrint("<%08x>: ", Address); KdbpPrint("<%08x>: ", Address);
else else
KdbpPrint(": "); KdbpPrint(": ");
@ -794,6 +794,7 @@ KdbpCmdBackTrace(
ULONGLONG Result = 0; ULONGLONG Result = 0;
ULONG_PTR Frame = KdbCurrentTrapFrame->Tf.Ebp; ULONG_PTR Frame = KdbCurrentTrapFrame->Tf.Ebp;
ULONG_PTR Address; ULONG_PTR Address;
KTRAP_FRAME TrapFrame;
if (Argc >= 2) if (Argc >= 2)
{ {
@ -853,15 +854,19 @@ KdbpCmdBackTrace(
KdbpPrint("Eip:\n"); KdbpPrint("Eip:\n");
/* Try printing the function at EIP */ /* Try printing the function at EIP */
if (!KdbSymPrintAddress((PVOID)KdbCurrentTrapFrame->Tf.Eip)) if (!KdbSymPrintAddress((PVOID)KdbCurrentTrapFrame->Tf.Eip, &KdbCurrentTrapFrame->Tf))
KdbpPrint("<%08x>\n", KdbCurrentTrapFrame->Tf.Eip); KdbpPrint("<%08x>\n", KdbCurrentTrapFrame->Tf.Eip);
else else
KdbpPrint("\n"); KdbpPrint("\n");
} }
TrapFrame = KdbCurrentTrapFrame->Tf;
KdbpPrint("Frames:\n"); KdbpPrint("Frames:\n");
for (;;) for (;;)
{ {
BOOLEAN GotNextFrame;
if (Frame == 0) if (Frame == 0)
break; break;
@ -871,8 +876,11 @@ KdbpCmdBackTrace(
break; break;
} }
if ((GotNextFrame = NT_SUCCESS(KdbpSafeReadMemory(&Frame, (PVOID)Frame, sizeof (ULONG_PTR)))))
TrapFrame.Ebp = Frame;
/* Print the location of the call instruction */ /* Print the location of the call instruction */
if (!KdbSymPrintAddress((PVOID)(Address - 5))) if (!KdbSymPrintAddress((PVOID)(Address - 5), &TrapFrame))
KdbpPrint("<%08x>\n", Address); KdbpPrint("<%08x>\n", Address);
else else
KdbpPrint("\n"); KdbpPrint("\n");
@ -882,7 +890,7 @@ KdbpCmdBackTrace(
if (Address == 0) if (Address == 0)
break; break;
if (!NT_SUCCESS(KdbpSafeReadMemory(&Frame, (PVOID)Frame, sizeof (ULONG_PTR)))) if (!GotNextFrame)
{ {
KdbpPrint("Couldn't access memory at 0x%p!\n", Frame); KdbpPrint("Couldn't access memory at 0x%p!\n", Frame);
break; break;
@ -2666,7 +2674,7 @@ KdbpCliMainLoop(
if (EnteredOnSingleStep) if (EnteredOnSingleStep)
{ {
if (!KdbSymPrintAddress((PVOID)KdbCurrentTrapFrame->Tf.Eip)) if (!KdbSymPrintAddress((PVOID)KdbCurrentTrapFrame->Tf.Eip, &KdbCurrentTrapFrame->Tf))
{ {
KdbpPrint("<%x>", KdbCurrentTrapFrame->Tf.Eip); KdbpPrint("<%x>", KdbCurrentTrapFrame->Tf.Eip);
} }

3
reactos/ntoskrnl/kdbg/kdb_symbols.c
View file

@ -122,7 +122,8 @@ KdbpSymFindModule(
*/ */
BOOLEAN BOOLEAN
KdbSymPrintAddress( KdbSymPrintAddress(
IN PVOID Address) IN PVOID Address,
IN PKTRAP_FRAME Context)
{ {
PLDR_DATA_TABLE_ENTRY LdrEntry; PLDR_DATA_TABLE_ENTRY LdrEntry;
ULONG_PTR RelativeAddress; ULONG_PTR RelativeAddress;

133
reactos/ntoskrnl/kdbg/kdb_symbols.cmake.c
View file

@ -28,7 +28,6 @@ typedef struct _IMAGE_SYMBOL_INFO_CACHE
IMAGE_SYMBOL_INFO_CACHE, *PIMAGE_SYMBOL_INFO_CACHE; IMAGE_SYMBOL_INFO_CACHE, *PIMAGE_SYMBOL_INFO_CACHE;
typedef struct _ROSSYM_KM_OWN_CONTEXT { typedef struct _ROSSYM_KM_OWN_CONTEXT {
ROSSYM_OWN_FILECONTEXT Rossym;
LARGE_INTEGER FileOffset; LARGE_INTEGER FileOffset;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
} ROSSYM_KM_OWN_CONTEXT, *PROSSYM_KM_OWN_CONTEXT; } ROSSYM_KM_OWN_CONTEXT, *PROSSYM_KM_OWN_CONTEXT;
@ -65,7 +64,7 @@ KdbpReadSymFile(PVOID FileContext, PVOID Buffer, ULONG Length)
return NT_SUCCESS(Status); return NT_SUCCESS(Status);
} }
static PROSSYM_OWN_FILECONTEXT static PROSSYM_KM_OWN_CONTEXT
KdbpCaptureFileForSymbols(PFILE_OBJECT FileObject) KdbpCaptureFileForSymbols(PFILE_OBJECT FileObject)
{ {
PROSSYM_KM_OWN_CONTEXT Context = ExAllocatePool(NonPagedPool, sizeof(*Context)); PROSSYM_KM_OWN_CONTEXT Context = ExAllocatePool(NonPagedPool, sizeof(*Context));
@ -73,15 +72,12 @@ KdbpCaptureFileForSymbols(PFILE_OBJECT FileObject)
ObReferenceObject(FileObject); ObReferenceObject(FileObject);
Context->FileOffset.QuadPart = 0; Context->FileOffset.QuadPart = 0;
Context->FileObject = FileObject; Context->FileObject = FileObject;
Context->Rossym.ReadFileProc = KdbpReadSymFile; return Context;
Context->Rossym.SeekFileProc = KdbpSeekSymFile;
return &Context->Rossym;
} }
static VOID static VOID
KdbpReleaseFileForSymbols(PROSSYM_OWN_FILECONTEXT FileContext) KdbpReleaseFileForSymbols(PROSSYM_KM_OWN_CONTEXT Context)
{ {
PROSSYM_KM_OWN_CONTEXT Context = (PROSSYM_KM_OWN_CONTEXT)FileContext;
ObDereferenceObject(Context->FileObject); ObDereferenceObject(Context->FileObject);
ExFreePool(Context); ExFreePool(Context);
} }
@ -175,31 +171,75 @@ KdbpSymFindModule(
*/ */
BOOLEAN BOOLEAN
KdbSymPrintAddress( KdbSymPrintAddress(
IN PVOID Address) IN PVOID Address,
IN PKTRAP_FRAME Context)
{ {
int i;
PMEMORY_AREA MemoryArea = NULL; PMEMORY_AREA MemoryArea = NULL;
PROS_SECTION_OBJECT SectionObject; PROS_SECTION_OBJECT SectionObject;
PLDR_DATA_TABLE_ENTRY LdrEntry; PLDR_DATA_TABLE_ENTRY LdrEntry;
PROSSYM_OWN_FILECONTEXT FileContext; PROSSYM_KM_OWN_CONTEXT FileContext;
ULONG_PTR RelativeAddress; ULONG_PTR RelativeAddress;
NTSTATUS Status; NTSTATUS Status;
ULONG LineNumber; ROSSYM_LINEINFO LineInfo = { };
CHAR FileName[256];
CHAR FunctionName[256]; struct {
enum _ROSSYM_REGNAME regname;
size_t ctx_offset;
} regmap[] = {
{ ROSSYM_X86_EDX, FIELD_OFFSET(KTRAP_FRAME, Edx) },
{ ROSSYM_X86_EAX, FIELD_OFFSET(KTRAP_FRAME, Eax) },
{ ROSSYM_X86_ECX, FIELD_OFFSET(KTRAP_FRAME, Ecx) },
{ ROSSYM_X86_EBX, FIELD_OFFSET(KTRAP_FRAME, Ebx) },
{ ROSSYM_X86_ESI, FIELD_OFFSET(KTRAP_FRAME, Esi) },
{ ROSSYM_X86_EDI, FIELD_OFFSET(KTRAP_FRAME, Edi) },
{ ROSSYM_X86_EBP, FIELD_OFFSET(KTRAP_FRAME, Ebp) },
{ ROSSYM_X86_ESP, FIELD_OFFSET(KTRAP_FRAME, HardwareEsp) }
};
if (Context)
{
DPRINT("Has Context %x (EBP %x)\n", Context, Context->Ebp);
LineInfo.Flags = ROSSYM_LINEINFO_HAS_REGISTERS;
for (i = 0; i < sizeof(regmap) / sizeof(regmap[0]); i++) {
memcpy
(&LineInfo.Registers.Registers[regmap[i].regname],
((PCHAR)Context)+regmap[i].ctx_offset,
sizeof(ULONG_PTR));
DPRINT("DWARF REG[%d] -> %x\n", regmap[i].regname, LineInfo.Registers.Registers[regmap[i].regname]);
}
}
if (!KdbpSymbolsInitialized || !KdbpSymFindModule(Address, NULL, -1, &LdrEntry)) if (!KdbpSymbolsInitialized || !KdbpSymFindModule(Address, NULL, -1, &LdrEntry))
return FALSE; return FALSE;
RelativeAddress = (ULONG_PTR)Address - (ULONG_PTR)LdrEntry->DllBase; RelativeAddress = (ULONG_PTR)Address - (ULONG_PTR)LdrEntry->DllBase;
Status = KdbSymGetAddressInformation(LdrEntry->PatchInformation, Status = KdbSymGetAddressInformation
RelativeAddress, (LdrEntry->PatchInformation,
&LineNumber, RelativeAddress,
FileName, &LineInfo);
FunctionName);
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
{ {
DbgPrint("<%wZ:%x (%s:%d (%s))>", DbgPrint("<%wZ:%x (%s:%d (%s))>",
&LdrEntry->BaseDllName, RelativeAddress, FileName, LineNumber, FunctionName); &LdrEntry->BaseDllName, RelativeAddress, LineInfo.FileName, LineInfo.LineNumber, LineInfo.FunctionName);
if (Context)
{
int i;
char *comma = "";
DbgPrint("(");
for (i = 0; i < LineInfo.NumParams; i++) {
DbgPrint
("%s%s=%llx",
comma,
LineInfo.Parameters[i].ValueName,
LineInfo.Parameters[i].Value);
comma = ",";
}
DbgPrint(")");
}
return TRUE; return TRUE;
} }
else if (Address < MmSystemRangeStart) else if (Address < MmSystemRangeStart)
@ -232,18 +272,37 @@ KdbSymPrintAddress(
if (KdbpRosSymInfo) if (KdbpRosSymInfo)
{ {
RelativeAddress = (ULONG_PTR)Address - KdbpImageBase; RelativeAddress = (ULONG_PTR)Address - KdbpImageBase;
RosSymFreeInfo(&LineInfo);
Status = KdbSymGetAddressInformation Status = KdbSymGetAddressInformation
(KdbpRosSymInfo, (KdbpRosSymInfo,
RelativeAddress, RelativeAddress,
&LineNumber, &LineInfo);
FileName,
FunctionName);
if (NT_SUCCESS(Status)) if (NT_SUCCESS(Status))
{ {
DbgPrint DbgPrint
("<%wZ:%x (%s:%d (%s))>", ("<%wZ:%x (%s:%d (%s))>",
&SectionObject->FileObject->FileName, &SectionObject->FileObject->FileName,
RelativeAddress, FileName, LineNumber, FunctionName); RelativeAddress,
LineInfo.FileName,
LineInfo.LineNumber,
LineInfo.FunctionName);
if (Context)
{
int i;
char *comma = "";
DbgPrint("(");
for (i = 0; i < LineInfo.NumParams; i++) {
DbgPrint
("%s%s=%llx",
comma,
LineInfo.Parameters[i].ValueName,
LineInfo.Parameters[i].Value);
comma = ",";
}
DbgPrint(")");
}
return TRUE; return TRUE;
} }
} }
@ -276,13 +335,11 @@ NTSTATUS
KdbSymGetAddressInformation( KdbSymGetAddressInformation(
IN PROSSYM_INFO RosSymInfo, IN PROSSYM_INFO RosSymInfo,
IN ULONG_PTR RelativeAddress, IN ULONG_PTR RelativeAddress,
OUT PULONG LineNumber OPTIONAL, IN PROSSYM_LINEINFO LineInfo)
OUT PCH FileName OPTIONAL,
OUT PCH FunctionName OPTIONAL)
{ {
if (!KdbpSymbolsInitialized || if (!KdbpSymbolsInitialized ||
!RosSymInfo || !RosSymInfo ||
!RosSymGetAddressInformation(RosSymInfo, RelativeAddress, LineNumber, FileName, FunctionName)) !RosSymGetAddressInformation(RosSymInfo, RelativeAddress, LineInfo))
{ {
return STATUS_UNSUCCESSFUL; return STATUS_UNSUCCESSFUL;
} }
@ -429,7 +486,7 @@ KdbpSymLoadModuleSymbols(
NTSTATUS Status; NTSTATUS Status;
IO_STATUS_BLOCK IoStatusBlock; IO_STATUS_BLOCK IoStatusBlock;
PFILE_OBJECT FileObject; PFILE_OBJECT FileObject;
PROSSYM_OWN_FILECONTEXT FileContext; PROSSYM_KM_OWN_CONTEXT FileContext;
/* Allow KDB to break on module load */ /* Allow KDB to break on module load */
KdbModuleLoaded(FileName); KdbModuleLoaded(FileName);
@ -536,6 +593,26 @@ KdbDebugPrint(
/* Nothing here */ /* Nothing here */
} }
static PVOID KdbpSymAllocMem(ULONG_PTR size)
{
return ExAllocatePoolWithTag(NonPagedPool, size, 'RSYM');
}
static VOID KdbpSymFreeMem(PVOID Area)
{
return ExFreePool(Area);
}
static BOOLEAN KdbpSymReadMem(PVOID FileContext, PVOID TargetDebug, PVOID SourceMem, ULONG Size)
{
return NT_SUCCESS(KdbpSafeReadMemory(TargetDebug, SourceMem, Size));
}
static ROSSYM_CALLBACKS KdbpRosSymCallbacks = {
KdbpSymAllocMem, KdbpSymFreeMem,
KdbpReadSymFile, KdbpSeekSymFile,
KdbpSymReadMem
};
/*! \brief Initializes the KDB symbols implementation. /*! \brief Initializes the KDB symbols implementation.
* *
@ -621,7 +698,7 @@ KdbInitialize(
p1 = p2; p1 = p2;
} }
RosSymInitKernelMode(); RosSymInit(&KdbpRosSymCallbacks);
} }
else if (BootPhase == 3) else if (BootPhase == 3)
{ {

2
reactos/ntoskrnl/ke/bug.c
View file

@ -266,7 +266,7 @@ KeRosDumpStackFrameArray(IN PULONG_PTR Frames,
if (p) if (p)
{ {
#ifdef KDBG #ifdef KDBG
if (!KdbSymPrintAddress((PVOID)Addr)) if (!KdbSymPrintAddress((PVOID)Addr, NULL))
#endif #endif
{ {
/* Print out the module name */ /* Print out the module name */