dwarfinfo.c File Reference

#include <precomp.h>
#include <debug.h>

Include dependency graph for dwarfinfo.c:

Go to the source code of this file.

Classes
struct	Parse

Macros
#define	NDEBUG
#define	ATTR(x)   (#x)+9, x
#define	OFFSET(x)   offsetof(DwarfAttrs, x), offsetof(DwarfAttrs, have.x)

Typedefs
typedef struct Parse	Parse

Enumerations
enum	{   DwarfAttrSibling = 0x01 , DwarfAttrLocation = 0x02 , DwarfAttrName = 0x03 , DwarfAttrOrdering = 0x09 ,   DwarfAttrByteSize = 0x0B , DwarfAttrBitOffset = 0x0C , DwarfAttrBitSize = 0x0D , DwarfAttrStmtList = 0x10 ,   DwarfAttrLowpc = 0x11 , DwarfAttrHighpc = 0x12 , DwarfAttrLanguage = 0x13 , DwarfAttrDiscr = 0x15 ,   DwarfAttrDiscrValue = 0x16 , DwarfAttrVisibility = 0x17 , DwarfAttrImport = 0x18 , DwarfAttrStringLength = 0x19 ,   DwarfAttrCommonRef = 0x1A , DwarfAttrCompDir = 0x1B , DwarfAttrConstValue = 0x1C , DwarfAttrContainingType = 0x1D ,   DwarfAttrDefaultValue = 0x1E , DwarfAttrInline = 0x20 , DwarfAttrIsOptional = 0x21 , DwarfAttrLowerBound = 0x22 ,   DwarfAttrProducer = 0x25 , DwarfAttrPrototyped = 0x27 , DwarfAttrReturnAddr = 0x2A , DwarfAttrStartScope = 0x2C ,   DwarfAttrStrideSize = 0x2E , DwarfAttrUpperBound = 0x2F , DwarfAttrAbstractOrigin = 0x31 , DwarfAttrAccessibility = 0x32 ,   DwarfAttrAddrClass = 0x33 , DwarfAttrArtificial = 0x34 , DwarfAttrBaseTypes = 0x35 , DwarfAttrCalling = 0x36 ,   DwarfAttrCount = 0x37 , DwarfAttrDataMemberLoc = 0x38 , DwarfAttrDeclColumn = 0x39 , DwarfAttrDeclFile = 0x3A ,   DwarfAttrDeclLine = 0x3B , DwarfAttrDeclaration = 0x3C , DwarfAttrDiscrList = 0x3D , DwarfAttrEncoding = 0x3E ,   DwarfAttrExternal = 0x3F , DwarfAttrFrameBase = 0x40 , DwarfAttrFriend = 0x41 , DwarfAttrIdentifierCase = 0x42 ,   DwarfAttrMacroInfo = 0x43 , DwarfAttrNamelistItem = 0x44 , DwarfAttrPriority = 0x45 , DwarfAttrSegment = 0x46 ,   DwarfAttrSpecification = 0x47 , DwarfAttrStaticLink = 0x48 , DwarfAttrType = 0x49 , DwarfAttrUseLocation = 0x4A ,   DwarfAttrVarParam = 0x4B , DwarfAttrVirtuality = 0x4C , DwarfAttrVtableElemLoc = 0x4D , DwarfAttrAllocated = 0x4E ,   DwarfAttrAssociated = 0x4F , DwarfAttrDataLocation = 0x50 , DwarfAttrStride = 0x51 , DwarfAttrEntrypc = 0x52 ,   DwarfAttrUseUTF8 = 0x53 , DwarfAttrExtension = 0x54 , DwarfAttrRanges = 0x55 , DwarfAttrTrampoline = 0x56 ,   DwarfAttrCallColumn = 0x57 , DwarfAttrCallFile = 0x58 , DwarfAttrCallLine = 0x59 , DwarfAttrDescription = 0x5A ,   DwarfAttrMax , FormAddr = 0x01 , FormDwarfBlock2 = 0x03 , FormDwarfBlock4 = 0x04 ,   FormData2 = 0x05 , FormData4 = 0x06 , FormData8 = 0x07 , FormString = 0x08 ,   FormDwarfBlock = 0x09 , FormDwarfBlock1 = 0x0A , FormData1 = 0x0B , FormFlag = 0x0C ,   FormSdata = 0x0D , FormStrp = 0x0E , FormUdata = 0x0F , FormRefAddr = 0x10 ,   FormRef1 = 0x11 , FormRef2 = 0x12 , FormRef4 = 0x13 , FormRef8 = 0x14 ,   FormRefUdata = 0x15 , FormIndirect = 0x16 }

Functions
static int	parseattrs (Dwarf *d, DwarfBuf *, ulong, ulong, DwarfAbbrev *, DwarfAttrs *)
static int	getulong (DwarfBuf *, int, ulong, ulong *, int *)
static int	getuchar (DwarfBuf *, int, uchar *)
static int	getstring (Dwarf *d, DwarfBuf *, int, char **)
static int	getblock (DwarfBuf *, int, DwarfBlock *)
static int	skipform (Dwarf *d, DwarfBuf *, int)
int	dwarflookupnameinunit (Dwarf *d, ulong unit, char *name, DwarfSym *s)
int	dwarflookupsubname (Dwarf *d, DwarfSym *parent, char *name, DwarfSym *s)
int	dwarflookupchildtag (Dwarf *d, DwarfSym *parent, ulong tag, DwarfSym *s)
int	dwarflookuptag (Dwarf *d, ulong unit, ulong tag, DwarfSym *s)
int	dwarfseeksym (Dwarf *d, ulong unit, ulong off, DwarfSym *s)
int	dwarflookupfn (Dwarf *d, ulong unit, ulong pc, DwarfSym *s)
int	dwarfenumunit (Dwarf *d, ulong unit, DwarfSym *s)
int	dwarfnextsym (Dwarf *d, DwarfSym *s)
int	dwarfnextsymat (Dwarf *d, DwarfSym *parent, DwarfSym *child)
void	stackinit (DwarfStack *stack)
void	stackpush (DwarfStack *stack, ulong value)
ulong	stackpop (DwarfStack *stack)
void	stackfree (DwarfStack *stack)
int	dwarfgetarg (Dwarf *d, const char *name, DwarfBuf *buf, ulong cfa, PROSSYM_REGISTERS registers, ulong *result)
int	dwarfargvalue (Dwarf *d, DwarfSym *proc, ulong pc, ulong cfa, PROSSYM_REGISTERS registers, DwarfParam *parameter)
void	dwarfdumpsym (Dwarf *d, DwarfSym *s)
int	dwarfgetparams (Dwarf *d, DwarfSym *s, ulong pc, int pnum, DwarfParam *paramblocks)

Variables
static Parse	plist []
static Parse	ptab [DwarfAttrMax]

Macro Definition Documentation

ATTR

#define ATTR

(

x

)

(#x)+9, x

Definition at line 334 of file dwarfinfo.c.

NDEBUG

#define NDEBUG

Definition at line 6 of file dwarfinfo.c.

OFFSET

#define OFFSET

(

x

)

offsetof(DwarfAttrs, x), offsetof(DwarfAttrs, have.x)

Definition at line 335 of file dwarfinfo.c.

Typedef Documentation

Parse

typedef struct Parse Parse

Definition at line 325 of file dwarfinfo.c.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
DwarfAttrSibling
DwarfAttrLocation
DwarfAttrName
DwarfAttrOrdering
DwarfAttrByteSize
DwarfAttrBitOffset
DwarfAttrBitSize
DwarfAttrStmtList
DwarfAttrLowpc
DwarfAttrHighpc
DwarfAttrLanguage
DwarfAttrDiscr
DwarfAttrDiscrValue
DwarfAttrVisibility
DwarfAttrImport
DwarfAttrStringLength
DwarfAttrCommonRef
DwarfAttrCompDir
DwarfAttrConstValue
DwarfAttrContainingType
DwarfAttrDefaultValue
DwarfAttrInline
DwarfAttrIsOptional
DwarfAttrLowerBound
DwarfAttrProducer
DwarfAttrPrototyped
DwarfAttrReturnAddr
DwarfAttrStartScope
DwarfAttrStrideSize
DwarfAttrUpperBound
DwarfAttrAbstractOrigin
DwarfAttrAccessibility
DwarfAttrAddrClass
DwarfAttrArtificial
DwarfAttrBaseTypes
DwarfAttrCalling
DwarfAttrCount
DwarfAttrDataMemberLoc
DwarfAttrDeclColumn
DwarfAttrDeclFile
DwarfAttrDeclLine
DwarfAttrDeclaration
DwarfAttrDiscrList
DwarfAttrEncoding
DwarfAttrExternal
DwarfAttrFrameBase
DwarfAttrFriend
DwarfAttrIdentifierCase
DwarfAttrMacroInfo
DwarfAttrNamelistItem
DwarfAttrPriority
DwarfAttrSegment
DwarfAttrSpecification
DwarfAttrStaticLink
DwarfAttrType
DwarfAttrUseLocation
DwarfAttrVarParam
DwarfAttrVirtuality
DwarfAttrVtableElemLoc
DwarfAttrAllocated
DwarfAttrAssociated
DwarfAttrDataLocation
DwarfAttrStride
DwarfAttrEntrypc
DwarfAttrUseUTF8
DwarfAttrExtension
DwarfAttrRanges
DwarfAttrTrampoline
DwarfAttrCallColumn
DwarfAttrCallFile
DwarfAttrCallLine
DwarfAttrDescription
DwarfAttrMax
FormAddr
FormDwarfBlock2
FormDwarfBlock4
FormData2
FormData4
FormData8
FormString
FormDwarfBlock
FormDwarfBlock1
FormData1
FormFlag
FormSdata
FormStrp
FormUdata
FormRefAddr
FormRef1
FormRef2
FormRef4
FormRef8
FormRefUdata
FormIndirect

Definition at line 9 of file dwarfinfo.c.

{
    DwarfAttrSibling = 0x01,
    DwarfAttrLocation = 0x02,
    DwarfAttrName = 0x03,
    DwarfAttrOrdering = 0x09,
    DwarfAttrByteSize = 0x0B,
    DwarfAttrBitOffset = 0x0C,
    DwarfAttrBitSize = 0x0D,
    DwarfAttrStmtList = 0x10,
    DwarfAttrLowpc = 0x11,
    DwarfAttrHighpc = 0x12,
    DwarfAttrLanguage = 0x13,
    DwarfAttrDiscr = 0x15,
    DwarfAttrDiscrValue = 0x16,
    DwarfAttrVisibility = 0x17,
    DwarfAttrImport = 0x18,
    DwarfAttrStringLength = 0x19,
    DwarfAttrCommonRef = 0x1A,
    DwarfAttrCompDir = 0x1B,
    DwarfAttrConstValue = 0x1C,
    DwarfAttrContainingType = 0x1D,
    DwarfAttrDefaultValue = 0x1E,
    DwarfAttrInline = 0x20,
    DwarfAttrIsOptional = 0x21,
    DwarfAttrLowerBound = 0x22,
    DwarfAttrProducer = 0x25,
    DwarfAttrPrototyped = 0x27,
    DwarfAttrReturnAddr = 0x2A,
    DwarfAttrStartScope = 0x2C,
    DwarfAttrStrideSize = 0x2E,
    DwarfAttrUpperBound = 0x2F,
    DwarfAttrAbstractOrigin = 0x31,
    DwarfAttrAccessibility = 0x32,
    DwarfAttrAddrClass = 0x33,
    DwarfAttrArtificial = 0x34,
    DwarfAttrBaseTypes = 0x35,
    DwarfAttrCalling = 0x36,
    DwarfAttrCount = 0x37,
    DwarfAttrDataMemberLoc = 0x38,
    DwarfAttrDeclColumn = 0x39,
    DwarfAttrDeclFile = 0x3A,
    DwarfAttrDeclLine = 0x3B,
    DwarfAttrDeclaration = 0x3C,
    DwarfAttrDiscrList = 0x3D,
    DwarfAttrEncoding = 0x3E,
    DwarfAttrExternal = 0x3F,
    DwarfAttrFrameBase = 0x40,
    DwarfAttrFriend = 0x41,
    DwarfAttrIdentifierCase = 0x42,
    DwarfAttrMacroInfo = 0x43,
    DwarfAttrNamelistItem = 0x44,
    DwarfAttrPriority = 0x45,
    DwarfAttrSegment = 0x46,
    DwarfAttrSpecification = 0x47,
    DwarfAttrStaticLink = 0x48,
    DwarfAttrType = 0x49,
    DwarfAttrUseLocation = 0x4A,
    DwarfAttrVarParam = 0x4B,
    DwarfAttrVirtuality = 0x4C,
    DwarfAttrVtableElemLoc = 0x4D,
    DwarfAttrAllocated = 0x4E,
    DwarfAttrAssociated = 0x4F,
    DwarfAttrDataLocation = 0x50,
    DwarfAttrStride = 0x51,
    DwarfAttrEntrypc = 0x52,
    DwarfAttrUseUTF8 = 0x53,
    DwarfAttrExtension = 0x54,
    DwarfAttrRanges = 0x55,
    DwarfAttrTrampoline = 0x56,
    DwarfAttrCallColumn = 0x57,
    DwarfAttrCallFile = 0x58,
    DwarfAttrCallLine = 0x59,
    DwarfAttrDescription = 0x5A,
    DwarfAttrMax,
 
    FormAddr = 0x01,
    FormDwarfBlock2 = 0x03,
    FormDwarfBlock4 = 0x04,
    FormData2 = 0x05,
    FormData4 = 0x06,
    FormData8 = 0x07,
    FormString = 0x08,
    FormDwarfBlock = 0x09,
    FormDwarfBlock1 = 0x0A,
    FormData1 = 0x0B,
    FormFlag = 0x0C,
    FormSdata = 0x0D,
    FormStrp = 0x0E,
    FormUdata = 0x0F,
    FormRefAddr = 0x10,
    FormRef1 = 0x11,
    FormRef2 = 0x12,
    FormRef4 = 0x13,
    FormRef8 = 0x14,
    FormRefUdata = 0x15,
    FormIndirect = 0x16
};

Function Documentation

dwarfargvalue()

int dwarfargvalue	(	Dwarf *	d,
		DwarfSym *	proc,
		ulong	pc,
		ulong	cfa,
		PROSSYM_REGISTERS	registers,
		DwarfParam *	parameter
	)

Definition at line 909 of file dwarfinfo.c.

{
    int gotarg;
    DwarfSym unit = { };
 
    if (dwarfenumunit(d, proc->unit, &unit) == -1)
        return -1;
 
    werrstr("lookup in unit %x-%x, pc %x", unit.attrs.lowpc, unit.attrs.highpc, pc);
    pc -= unit.attrs.lowpc;
 
    werrstr("paramblock %s -> unit %x type %x fde %x len %d registers %x",
            parameter->name,
            parameter->unit,
            parameter->type,
            parameter->fde,
            parameter->len,
            registers);
 
    // Seek our range in loc
    DwarfBuf locbuf;
    DwarfBuf instream = { };
 
    locbuf.d = d;
    locbuf.addrsize = d->addrsize;
 
    if (parameter->loctype == TConstant) {
        locbuf.p = d->loc.data + parameter->fde;
        locbuf.ep = d->loc.data + d->loc.len;
        ulong start, end, len;
        do {
            len = 0;
            start = dwarfget4(&locbuf);
            end = dwarfget4(&locbuf);
            if (start && end) {
                len = dwarfget2(&locbuf);
                instream = locbuf;
                instream.ep = instream.p + len;
                locbuf.p = instream.ep;
            }
            werrstr("ip %x s %x e %x (%x bytes)", pc, start, end, len);
        } while (start && end && (start > pc || end <= pc));
    } else if (parameter->loctype == TBlock) {
        instream = locbuf;
        instream.p = (void *)parameter->fde;
        instream.ep = instream.p + parameter->len;
    } else {
        werrstr("Wrong block type for parameter %s", parameter->name);
        return -1;
    }
 
    gotarg = dwarfgetarg(d, parameter->name, &instream, cfa, registers, &parameter->value);
    if (gotarg == -1)
        return -1;
 
    return 0;
}

Referenced by RosSymGetAddressInformation().

dwarfdumpsym()

void dwarfdumpsym	(	Dwarf *	d,
		DwarfSym *	s
	)

Definition at line 968 of file dwarfinfo.c.

{
    int j;
    werrstr("tag %x\n", s->attrs.tag);
    for (j = 0; plist[j].name; j++) {
        char *have = ((char*)&s->attrs) + plist[j].haveoff;
        char *attr = ((char*)&s->attrs) + plist[j].off;
        if (*have == TString) {
            char *str = *((char **)attr);
            werrstr("%s: %s\n", plist[j].namestr, str);
        } else if (*have == TReference) {
            DwarfVal *val = ((DwarfVal*)attr);
            werrstr("%s: %x:%x\n", plist[j].namestr, val->b.data, val->b.len);
        } else if (*have)
            werrstr("%s: (%x)\n", plist[j].namestr, *have);
    }
}

dwarfenumunit()

int dwarfenumunit	(	Dwarf *	d,
		ulong	unit,
		DwarfSym *	s
	)

Definition at line 210 of file dwarfinfo.c.

{
    int i;
    ulong aoff, len;
 
    if(unit >= d->info.len){
        werrstr("dwarf unit address 0x%x >= 0x%x out of range", unit, d->info.len);
        return -1;
    }
    memset(s, 0, sizeof *s);
    memset(&s->b, 0, sizeof s->b);
 
    s->b.d = d;
    s->b.p = d->info.data + unit;
    s->b.ep = d->info.data + d->info.len;
    len = dwarfget4(&s->b);
    s->unit = unit;
    s->nextunit = unit + 4 + len;
    s->b.ep = d->info.data + s->nextunit;
 
    if(s->b.ep - s->b.p < len){
    badheader:
        werrstr("bad dwarf unit header at unit 0x%lux end %x start %x len %x", unit, s->b.ep - d->info.data, s->b.p - d->info.data, len);
        return -1;
    }
    s->b.ep = s->b.p+len;
    if((i=dwarfget2(&s->b)) > 4)
        goto badheader;
    aoff = dwarfget4(&s->b);
    s->b.addrsize = dwarfget1(&s->b);
    if(d->addrsize == 0)
        d->addrsize = s->b.addrsize;
    if(s->b.p == nil)
        goto badheader;
 
    s->aoff = aoff;
 
    return dwarfnextsym(d, s);
}

Referenced by _dwarfnametounit(), and dwarfpctoline().

dwarfgetarg()

int dwarfgetarg	(	Dwarf *	d,
		const char *	name,
		DwarfBuf *	buf,
		ulong	cfa,
		PROSSYM_REGISTERS	registers,
		ulong *	result
	)

Definition at line 658 of file dwarfinfo.c.

{
    int ret = 0;
    DwarfStack stack = { };
    stackinit(&stack);
    stackpush(&stack, cfa);
    while (buf->p < buf->ep) {
        int opcode = dwarfget1(buf);
        werrstr("opcode %x", opcode);
        switch (opcode) {
        case 0:
            buf->p = buf->ep;
            break;
        case OpAddr:
            if (d->addrsize == 4) {
                stackpush(&stack, dwarfget4(buf));
                break;
            } else {
                werrstr("%s: we only support 4 byte addrs", name);
                goto fatal;
            }
        case OpConst1s: {
            signed char c = dwarfget1(buf);
            stackpush(&stack, c);
        } break;
        case OpConst1u:
            stackpush(&stack, dwarfget1(buf));
            break;
        case OpConst2s: {
            signed short s = dwarfget2(buf);
            stackpush(&stack, s);
        } break;
        case OpConst2u:
            stackpush(&stack, dwarfget2(buf));
            break;
        case OpConst4s: {
            signed int i = dwarfget4(buf);
            stackpush(&stack, i);
        } break;
        case OpConst4u:
            stackpush(&stack, dwarfget4(buf));
            break;
        case OpConst8s:
        case OpConst8u:
            werrstr("const 8 not yet supported");
            goto fatal;
        case OpConsts:
            stackpush(&stack, dwarfget128s(buf));
            break;
        case OpConstu:
            stackpush(&stack, dwarfget128(buf));
            break;
        case OpDup: {
            ulong popped = stackpop(&stack);
            stackpush(&stack, popped);
            stackpush(&stack, popped);
        } break;
        case OpDrop:
            stackpop(&stack);
            break;
        case OpOver: {
            if (stack.length < 2) goto fatal;
            stackpush(&stack, stack.data[stack.length-2]);
        } break;
        case OpPick: {
            ulong arg = dwarfget1(buf);
            if (arg >= stack.length) goto fatal;
            arg = stack.data[stack.length-1-arg];
            stackpush(&stack, arg);
        } break;
        case OpSwap: {
            ulong a = stackpop(&stack), b = stackpop(&stack);
            stackpush(&stack, b);
            stackpush(&stack, a);
        } break;
        case OpRot: {
            ulong a = stackpop(&stack), b = stackpop(&stack), c = stackpop(&stack);
            stackpush(&stack, b);
            stackpush(&stack, c);
            stackpush(&stack, a);
        } break;
        case OpXderef:
        case OpXderefSize:
            werrstr("Xderef not yet supported");
            goto fatal;
        case OpAbs: {
            long a = stackpop(&stack);
            stackpush(&stack, a < 0 ? -a : a);
        } break;
        case OpAnd:
            stackpush(&stack, stackpop(&stack) & stackpop(&stack));
            break;
        case OpDiv: {
            ulong a = stackpop(&stack), b = stackpop(&stack);
            stackpush(&stack, b / a);
        } break;
        case OpMinus: {
            ulong a = stackpop(&stack), b = stackpop(&stack);
            stackpush(&stack, b - a);
        } break;
        case OpMod: {
            ulong a = stackpop(&stack), b = stackpop(&stack);
            stackpush(&stack, b % a);
        } break;
        case OpMul:
            stackpush(&stack, stackpop(&stack) * stackpop(&stack));
            break;
        case OpNeg:
            stackpush(&stack, -stackpop(&stack));
            break;
        case OpNot:
            stackpush(&stack, ~stackpop(&stack));
            break;
        case OpOr:
            stackpush(&stack, stackpop(&stack) | stackpop(&stack));
            break;
        case OpPlus:
            stackpush(&stack, stackpop(&stack) + stackpop(&stack));
            break;
        case OpPlusUconst:
            stackpush(&stack, stackpop(&stack) + dwarfget128(buf));
            break;
        case OpShl: {
            ulong a = stackpop(&stack), b = stackpop(&stack);
            stackpush(&stack, b << a);
        } break;
        case OpShr: {
            ulong a = stackpop(&stack), b = stackpop(&stack);
            stackpush(&stack, b >> a);
        } break;
        case OpShra: {
            ulong a = stackpop(&stack);
            long b = stackpop(&stack);
            if (b < 0)
                b = -(-b >> a);
            else
                b = b >> a;
            stackpush(&stack, b);
        } break;
        case OpXor:
            stackpush(&stack, stackpop(&stack) ^ stackpop(&stack));
            break;
        case OpSkip:
            buf->p += dwarfget2(buf);
            break;
        case OpBra: {
            ulong a = dwarfget2(buf);
            if (stackpop(&stack))
                buf->p += a;
        } break;
        case OpEq:
            stackpush(&stack, stackpop(&stack) == stackpop(&stack));
            break;
        case OpGe: {
            ulong a = stackpop(&stack), b = stackpop(&stack);
            stackpush(&stack, b >= a);
        } break;
        case OpGt: {
            ulong a = stackpop(&stack), b = stackpop(&stack);
            stackpush(&stack, b > a);
        } break;
        case OpLe: {
            ulong a = stackpop(&stack), b = stackpop(&stack);
            stackpush(&stack, b <= a);
        } break;
        case OpLt: {
            ulong a = stackpop(&stack), b = stackpop(&stack);
            stackpush(&stack, b < a);
        } break;
        case OpNe:
            stackpush(&stack, stackpop(&stack) != stackpop(&stack));
            break;
        case OpNop:
            break;
        case OpDeref: {
            ulong val;
            void* addr = (void*)stackpop(&stack);
            if (!RosSymCallbacks.MemGetProc
                (d->pe->fd,
                 &val,
                 addr,
                 d->addrsize))
                goto fatal;
            stackpush(&stack, val);
        } break;
        case OpDerefSize: {
            ulong val, size = dwarfget1(buf);
            void* addr = (void*)stackpop(&stack);
            if (!RosSymCallbacks.MemGetProc
                (d->pe->fd,
                 &val,
                 addr,
                 size))
                goto fatal;
            stackpush(&stack, val);
        } break;
        case OpFbreg: {
            ulong val, offset = dwarfget128s(buf);
            void* addr = (void*)cfa;
            werrstr("FBREG cfa %x offset %x", cfa, offset);
            if (!RosSymCallbacks.MemGetProc
                (d->pe->fd,
                 &val,
                 (PVOID)((ULONG_PTR)addr+offset),
                 d->addrsize))
                goto fatal;
            stackpush(&stack, val);
        } break;
        case OpPiece:
            werrstr("OpPiece not supported");
            goto fatal;
        default:
            if (opcode >= OpLit0 && opcode < OpReg0)
                stackpush(&stack, opcode - OpLit0);
            else if (opcode >= OpReg0 && opcode < OpBreg0) {
                ulong reg = opcode - OpReg0;
                werrstr("REG[%d] value %x", reg, (ulong)registers->Registers[reg]);
                stackpush(&stack, registers->Registers[reg]);
            } else if (opcode >= OpBreg0 && opcode < OpRegx) {
                ulong val,
                    reg = opcode - OpBreg0,
                    offset = dwarfget128s(buf);
                void* addr = (void*)(ULONG_PTR)registers->Registers[reg];
                werrstr("BREG[%d] reg %x offset %x", reg, addr, offset);
                if (!RosSymCallbacks.MemGetProc
                    ((PVOID)d->pe->fd,
                     &val,
                     (PVOID)((ULONG_PTR)addr + offset),
                     d->addrsize))
                    goto fatal;
                stackpush(&stack, val);
            } else {
                werrstr("opcode %x not supported", opcode);
                goto fatal;
            }
            break;
        }
    }
    if (stack.length < 1) goto fatal;
    *result = stackpop(&stack);
    werrstr("%s: value %x", name, *result);
    goto finish;
 
fatal:
    ret = -1;
 
finish:
    stackfree(&stack);
    return ret;
}

Referenced by dwarfargvalue(), and RosSymAggregate().

dwarfgetparams()

int dwarfgetparams	(	Dwarf *	d,
		DwarfSym *	s,
		ulong	pc,
		int	pnum,
		DwarfParam *	paramblocks
	)

Definition at line 987 of file dwarfinfo.c.

{
    int ip = 0;
    DwarfSym param = { };
    int res = dwarfnextsymat(d, s, &param);
    while (res == 0 && ip < pnum) {
        if (param.attrs.tag == TagFormalParameter &&
            param.attrs.have.name &&
            param.attrs.have.location) {
            paramblocks[ip].name = malloc(strlen(param.attrs.name)+1);
            strcpy(paramblocks[ip].name, param.attrs.name);
            paramblocks[ip].unit = param.unit;
            paramblocks[ip].type = param.attrs.type;
            paramblocks[ip].loctype = param.attrs.have.location;
            paramblocks[ip].len = param.attrs.location.b.len;
            paramblocks[ip].fde = (ulong)param.attrs.location.b.data;
            werrstr("param[%d] block %s -> type %x loctype %x fde %x len %x",
                   ip,
                   paramblocks[ip].name,
                   paramblocks[ip].type,
                   paramblocks[ip].loctype,
                   paramblocks[ip].fde,
                   paramblocks[ip].len);
            ip++;
        }
        res = dwarfnextsymat(d, s, &param);
    }
    return ip;
}

Referenced by RosSymGetAddressInformation().

dwarflookupchildtag()

int dwarflookupchildtag	(	Dwarf *	d,
		DwarfSym *	parent,
		ulong	tag,
		DwarfSym *	s
	)

Definition at line 142 of file dwarfinfo.c.

{
    int rsym = dwarfnextsymat(d, parent, s);
    while (rsym == 0 && s->attrs.tag != tag) {
        if (s->attrs.haskids) {
            DwarfSym p = *s;
            int csym = dwarflookupchildtag(d, &p, tag, s);
            if (csym == 0) {
                return csym;
            }
        }
        rsym = dwarfnextsym(d, s);
    }
    return rsym;
}

Referenced by dwarflookupchildtag(), and dwarflookuptag().

dwarflookupfn()

int dwarflookupfn	(	Dwarf *	d,
		ulong	unit,
		ulong	pc,
		DwarfSym *	s
	)

Definition at line 194 of file dwarfinfo.c.

{
    DwarfSym compunit = { };
    if(dwarfenumunit(d, unit, &compunit) < 0)
        return -1;
    while(dwarfnextsymat(d, &compunit, s) == 0){
        if(s->attrs.tag != TagSubprogram)
            continue;
        if(s->attrs.lowpc <= pc && pc < s->attrs.highpc)
            return 0;
    }
    werrstr("fn containing pc 0x%lux not found", pc);
    return -1;
}

Referenced by dwarfpctoline().

dwarflookupnameinunit()

int dwarflookupnameinunit	(	Dwarf *	d,
		ulong	unit,
		char *	name,
		DwarfSym *	s
	)

Definition at line 116 of file dwarfinfo.c.

{
    DwarfSym compunit = { };
    if(dwarfenumunit(d, unit, &compunit) < 0)
        return -1;
    while(dwarfnextsymat(d, &compunit, s) == 0) {
        werrstr("got %s looking for %s\n", s->attrs.name, name);
        if(s->attrs.name && strcmp(s->attrs.name, name) == 0)
            return 0;
    }
    werrstr("symbol '%s' not found", name);
    return -1;
}

Referenced by RosSymAggregate().

dwarflookupsubname()

int dwarflookupsubname	(	Dwarf *	d,
		DwarfSym *	parent,
		char *	name,
		DwarfSym *	s
	)

Definition at line 131 of file dwarfinfo.c.

{
    *s = *parent;
    while(dwarfnextsymat(d, parent, s))
        if(s->attrs.name && strcmp(s->attrs.name, name) == 0)
            return 0;
    werrstr("symbol '%s' not found", name);
    return -1;
}

dwarflookuptag()

int dwarflookuptag	(	Dwarf *	d,
		ulong	unit,
		ulong	tag,
		DwarfSym *	s
	)

Definition at line 159 of file dwarfinfo.c.

{
    DwarfSym compunit = { };
    if (dwarfenumunit(d, unit, &compunit) < 0) {
        return -1;
    }
    do {
        if (compunit.attrs.tag == tag) {
            *s = compunit;
            return 0;
        }
        if (dwarflookupchildtag(d, &compunit, tag, s) == 0)
            return 0;
    } while(dwarfnextsym(d, &compunit) == 0);
    werrstr("symbol with tag 0x%lux not found", tag);
    return -1;
}

Referenced by dwarfpctoline().

dwarfnextsym()

int dwarfnextsym	(	Dwarf *	d,
		DwarfSym *	s
	)

Definition at line 251 of file dwarfinfo.c.

{
    ulong num;
    DwarfAbbrev *a;
 
    werrstr("sym at %x (left %x)\n", s->b.p - d->info.data, s->b.ep - s->b.p);
 
    num = dwarfget128(&s->b);
    werrstr("abbrev num %x\n", num);
    s->num = num;
    if(num == 0){
        return -1;
    }
 
    a = dwarfgetabbrev(d, s->aoff, num);
    werrstr("a %p\n", a);
    if(a == nil){
        werrstr("getabbrev %x %x for %x", s->aoff, num, s->unit);
        return -1;
    }
 
    if(parseattrs(d, &s->b, s->attrs.tag, s->unit, a, &s->attrs) < 0) {
        return -1;
    }
 
    if (s->attrs.haskids) {
        DwarfSym childSkip = { };
        s->childoff = s->b.p - d->info.data;
        werrstr("Set childoff at %x\n", s->childoff);
        int r = dwarfnextsymat(d, s, &childSkip);
        while (r == 0) {
            r = dwarfnextsym(d, &childSkip);
        }
        s->b = childSkip.b;
    } else {
        s->childoff = 0;
    }
    return 0;
}

Referenced by _dwarfnametounit(), dwarfpctoline(), and main().

dwarfnextsymat()

int dwarfnextsymat	(	Dwarf *	d,
		DwarfSym *	parent,
		DwarfSym *	child
	)

Definition at line 292 of file dwarfinfo.c.

{
    uint sib;
 
    if (!parent->attrs.haskids || !parent->childoff)
        return -1;
 
    child->unit = parent->unit;
    child->aoff = parent->aoff;
    child->depth = parent->depth + 1;
    if(child->attrs.have.sibling){
        sib = child->attrs.sibling;
        if(sib < d->info.len && d->info.data+sib > child->b.p)
            child->b.p = d->info.data+sib;
        else if (sib >= d->info.len) {
            werrstr("sibling reported as out of bounds %d vs %d", sib, d->info.len);
            return -1;
        } else if (d->info.data+sib+parent->unit < child->b.p) {
            werrstr("subsequent sibling is listed before prev %d vs %d", sib+parent->unit, child->b.p - d->info.data);
            return -1;
        }
    }
 
    // Uninitialized
    if (!child->b.d) {
        child->b = parent->b;
        child->b.p = parent->childoff + parent->b.d->info.data;
        werrstr("Rewound to childoff %x\n", parent->childoff);
    }
 
    return dwarfnextsym(d, child);
}

dwarfseeksym()

int dwarfseeksym	(	Dwarf *	d,
		ulong	unit,
		ulong	off,
		DwarfSym *	s
	)

Definition at line 178 of file dwarfinfo.c.

{
    DwarfSym compunit = { };
    if(dwarfenumunit(d, unit, &compunit) < 0)
        return -1;
    werrstr("dwarfseeksym: unit %x off %x\n", unit, off);
    s->b.d = d;
    s->b.p = d->info.data + unit + off;
    s->b.ep = compunit.b.ep;
    if(dwarfnextsymat(d, &compunit, s) == -1)
        return -1;
    werrstr("dwarfseeksym: unit %x off %x, tag %x", unit, off, s->attrs.tag);
    return 0;
}

Referenced by RosSymAggregate().

getblock()

static int getblock ( DwarfBuf *  b, int  form, DwarfBlock *  bl  )

static

Definition at line 580 of file dwarfinfo.c.

{
    ulong n;
 
    switch(form){
    default:
        return -1;
    case FormDwarfBlock:
        n = dwarfget128(b);
        goto copyn;
    case FormDwarfBlock1:
        n = dwarfget1(b);
        goto copyn;
    case FormDwarfBlock2:
        n = dwarfget2(b);
        goto copyn;
    case FormDwarfBlock4:
        n = dwarfget4(b);
    copyn:
        bl->data = dwarfgetnref(b, n);
        bl->len = n;
        if(bl->data == nil)
            return -1;
        return 0;
    }
}

getstring()

static int getstring ( Dwarf *  d, DwarfBuf *  b, int  form, char **  s  )

static

Definition at line 548 of file dwarfinfo.c.

{
    static int nbad;
    ulong u, x;
 
    switch(form){
    default:
        return -1;
 
    case FormString:
        x = b->p - d->info.data;
        *s = dwarfgetstring(b);
        for (u = 0; (*s)[u]; u++) {
            assert(isprint((*s)[u]));
        }
        return 0;
 
    case FormStrp:
        u = dwarfget4(b);
        if(u >= b->d->str.len){
            if(++nbad == 1)
                werrstr("dwarf: bad string pointer 0x%lux in attribute", u);
            /* don't return error - maybe can proceed */
            *s = nil;
        }else
            *s = (char*)b->d->str.data + u;
        return 0;
 
    }
}

getuchar()

static int getuchar ( DwarfBuf *  b, int  form, uchar *  u  )

static

Definition at line 535 of file dwarfinfo.c.

{
    switch(form){
    default:
        return -1;
 
    case FormFlag:
        *u = dwarfget1(b);
        return 0;
    }
}

getulong()

static int getulong ( DwarfBuf *  b, int  form, ulong  unit, ulong *  u, int *  type  )

static

Definition at line 467 of file dwarfinfo.c.

{
    static int nbad;
    uvlong uv;
 
    switch(form){
    default:
        return -1;
 
    /* addresses */
    case FormAddr:
        *type = TAddress;
        *u = dwarfgetaddr(b);
        return 0;
 
    /* references */
    case FormRefAddr:
        /* absolute ref in .debug_info */
        *type = TReference;
        *u = dwarfgetaddr(b);
        return 0;
    case FormRef1:
        *u = dwarfget1(b);
        goto relativeref;
    case FormRef2:
        *u = dwarfget2(b);
        goto relativeref;
    case FormRef4:
        *u = dwarfget4(b);
        goto relativeref;
    case FormRef8:
        *u = dwarfget8(b);
        goto relativeref;
    case FormRefUdata:
        *u = dwarfget128(b);
    relativeref:
        *u += unit;
        *type = TReference;
        return 0;
 
    /* constants */
    case FormData1:
        *u = dwarfget1(b);
        goto constant;
    case FormData2:
        *u = dwarfget2(b);
        goto constant;
    case FormData4:
        *u = dwarfget4(b);
        goto constant;
    case FormData8:
        uv = dwarfget8(b);
        *u = uv;
        if(uv != *u && ++nbad == 1)
            werrstr("dwarf: truncating 64-bit attribute constants");
        goto constant;
    case FormSdata:
        *u = dwarfget128s(b);
        goto constant;
    case FormUdata:
        *u = dwarfget128(b);
    constant:
        *type = TConstant;
        return 0;
    }
}

parseattrs()

static int parseattrs ( Dwarf *  d, DwarfBuf *  b, ulong  tag, ulong  unit, DwarfAbbrev *  a, DwarfAttrs *  attrs  )

static

Definition at line 405 of file dwarfinfo.c.

{
    int i, f, n, got;
    static int nbad;
    void *v;
 
    /* initialize ptab first time through for quick access */
    if(ptab[DwarfAttrName].name != DwarfAttrName)
        for(i=0; plist[i].name; i++)
            ptab[plist[i].name] = plist[i];
 
    memset(attrs, 0, sizeof *attrs);
    attrs->tag = a->tag;
    attrs->haskids = a->haskids;
 
    for(i=0; i<a->nattr; i++){
        n = a->attr[i].name;
        f = a->attr[i].form;
        werrstr("struct: (@%x) n %x f %x (%d %d)\n", b->p - d->info.data, n, f, ptab[n].haveoff, ptab[n].off);
        if(n < 0 || n >= DwarfAttrMax || ptab[n].name==0) {
            if (skipform(d, b, f) < 0) {
                if(++nbad == 1)
                    werrstr("dwarf parse attrs: cannot skip form %d", f);
                return -1;
            }
            continue;
        }
        v = (char*)attrs + ptab[n].off;
        got = 0;
        if(f == FormIndirect)
            f = dwarfget128(b);
        if((ptab[n].type&(TConstant|TReference|TAddress))
           && getulong(b, f, unit, v, &got) >= 0)
            ;
        else if((ptab[n].type&TFlag) && getuchar(b, f, v) >= 0)
            got = TFlag;
        else if((ptab[n].type&TString) && getstring(d, b, f, v) >= 0)
            got = TString;
        else if((ptab[n].type&TBlock) && getblock(b, f, v) >= 0) {
            got = TBlock;
        } else {
            werrstr("Skipping form %x\n", f);
            if(skipform(d, b, f) < 0){
                //if(++nbad == 1)
                    werrstr("dwarf parse attrs: cannot skip form %d", f);
                return -1;
            }
        }
#if 0
        if(got == TBlock && (ptab[n].type&TConstant))
            got = constblock(b->d, v, v);
#endif
        *((uchar*)attrs+ptab[n].haveoff) = got;
    }
 
    if (attrs->have.name)
        werrstr("%s: tag %x kids %d (last %x)\n", attrs->name, attrs->tag, attrs->haskids, b->p - b->d->info.data);
 
    return 0;
}

skipform()

static int skipform ( Dwarf *  d, DwarfBuf *  b, int  form  )

static

Definition at line 609 of file dwarfinfo.c.

{
    int type;
    DwarfVal val;
 
    if(getulong(b, form, 0, &val.c, &type) < 0
       && getuchar(b, form, (uchar*)&val) < 0
       && getstring(d, b, form, &val.s) < 0
       && getblock(b, form, &val.b) < 0)
        return -1;
    return 0;
}

stackfree()

void stackfree

(

DwarfStack *

stack

)

Definition at line 651 of file dwarfinfo.c.

{
    if (stack->data != stack->storage)
        free(stack->data);
}

Referenced by dwarfgetarg().

stackinit()

void stackinit

(

DwarfStack *

stack

)

Definition at line 622 of file dwarfinfo.c.

{
    memset(stack, 0, sizeof(*stack));
    stack->data = stack->storage;
    stack->length = 0; stack->max = sizeof(stack->storage) / sizeof(stack->storage[0]);
}

Referenced by dwarfgetarg().

stackpop()

ulong stackpop

(

DwarfStack *

stack

)

Definition at line 643 of file dwarfinfo.c.

{
    ASSERT(stack->length > 0);
    ulong val = stack->data[--stack->length];
    werrstr("pop stack[%d] -> %x", stack->length, val);
    return val;
}

Referenced by dwarfgetarg().

stackpush()

void stackpush	(	DwarfStack *	stack,
		ulong	value
	)

Definition at line 629 of file dwarfinfo.c.

{
    if (stack->length == stack->max) {
        ulong *newstack = malloc(sizeof(ulong)*stack->max*2);
        memcpy(newstack, stack->data, sizeof(ulong)*stack->length);
        if (stack->data != stack->storage)
            free(stack->data);
        stack->data = newstack;
        stack->max *= 2;
    }
    werrstr("stack[%d] = %x", stack->length, value);
    stack->data[stack->length++] = value;
}

Referenced by dwarfgetarg().

Variable Documentation

plist

Parse plist[]

static

Definition at line 337 of file dwarfinfo.c.

ptab

Parse ptab[DwarfAttrMax]

static

Definition at line 402 of file dwarfinfo.c.