dwarf.h File Reference

#include "compat.h"

Include dependency graph for dwarf.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	DwarfBlock
struct	DwarfParam
struct	DwarfBuf
union	DwarfVal
struct	DwarfAttrs
struct	DwarfExpr
struct	DwarfSym
struct	DwarfAttr
struct	DwarfAbbrev
struct	Dwarf
struct	DwarfStack

Macros
#define	MAXIMUM_DWARF_NAME_SIZE   64

Typedefs
typedef struct Dwarf	Dwarf
typedef struct DwarfAttrs	DwarfAttrs
typedef struct DwarfBlock	DwarfBlock
typedef struct DwarfBuf	DwarfBuf
typedef struct DwarfExpr	DwarfExpr
typedef struct DwarfSym	DwarfSym
typedef struct DwarfStack	DwarfStack
typedef struct DwarfParam	DwarfParam
typedef union DwarfVal	DwarfVal
typedef struct DwarfAbbrev	DwarfAbbrev
typedef struct DwarfAttr	DwarfAttr

Enumerations
enum	{   TagArrayType = 0x01 , TagClassType = 0x02 , TagEntryPoint = 0x03 , TagEnumerationType = 0x04 ,   TagFormalParameter = 0x05 , TagImportedDeclaration = 0x08 , TagLabel = 0x0A , TagLexDwarfBlock = 0x0B ,   TagMember = 0x0D , TagPointerType = 0x0F , TagReferenceType = 0x10 , TagCompileUnit = 0x11 ,   TagStringType = 0x12 , TagStructType = 0x13 , TagSubroutineType = 0x15 , TagTypedef = 0x16 ,   TagUnionType = 0x17 , TagUnspecifiedParameters = 0x18 , TagVariant = 0x19 , TagCommonDwarfBlock = 0x1A ,   TagCommonInclusion = 0x1B , TagInheritance = 0x1C , TagInlinedSubroutine = 0x1D , TagModule = 0x1E ,   TagPtrToMemberType = 0x1F , TagSetType = 0x20 , TagSubrangeType = 0x21 , TagWithStmt = 0x22 ,   TagAccessDeclaration = 0x23 , TagBaseType = 0x24 , TagCatchDwarfBlock = 0x25 , TagConstType = 0x26 ,   TagConstant = 0x27 , TagEnumerator = 0x28 , TagFileType = 0x29 , TagFriend = 0x2A ,   TagNamelist = 0x2B , TagNamelistItem = 0x2C , TagPackedType = 0x2D , TagSubprogram = 0x2E ,   TagTemplateTypeParameter = 0x2F , TagTemplateValueParameter = 0x30 , TagThrownType = 0x31 , TagTryDwarfBlock = 0x32 ,   TagVariantPart = 0x33 , TagVariable = 0x34 , TagVolatileType = 0x35 , TagDwarfProcedure = 0x36 ,   TagRestrictType = 0x37 , TagInterfaceType = 0x38 , TagNamespace = 0x39 , TagImportedModule = 0x3A ,   TagUnspecifiedType = 0x3B , TagPartialUnit = 0x3C , TagImportedUnit = 0x3D , TagMutableType = 0x3E ,   TypeAddress = 0x01 , TypeBoolean = 0x02 , TypeComplexFloat = 0x03 , TypeFloat = 0x04 ,   TypeSigned = 0x05 , TypeSignedChar = 0x06 , TypeUnsigned = 0x07 , TypeUnsignedChar = 0x08 ,   TypeImaginaryFloat = 0x09 , AccessPublic = 0x01 , AccessProtected = 0x02 , AccessPrivate = 0x03 ,   VisLocal = 0x01 , VisExported = 0x02 , VisQualified = 0x03 , VirtNone = 0x00 ,   VirtVirtual = 0x01 , VirtPureVirtual = 0x02 , LangC89 = 0x0001 , LangC = 0x0002 ,   LangAda83 = 0x0003 , LangCplusplus = 0x0004 , LangCobol74 = 0x0005 , LangCobol85 = 0x0006 ,   LangFortran77 = 0x0007 , LangFortran90 = 0x0008 , LangPascal83 = 0x0009 , LangModula2 = 0x000A ,   LangJava = 0x000B , LangC99 = 0x000C , LangAda95 = 0x000D , LangFortran95 = 0x000E ,   LangPLI = 0x000F , IdCaseSensitive = 0x00 , IdCaseUpper = 0x01 , IdCaseLower = 0x02 ,   IdCaseInsensitive = 0x03 , CallingNormal = 0x01 , CallingProgram = 0x02 , CallingNocall = 0x03 ,   InNone = 0x00 , InInlined = 0x01 , InDeclaredNotInlined = 0x02 , InDeclaredInlined = 0x03 ,   OrderRowMajor = 0x00 , OrderColumnMajor = 0x01 , DiscLabel = 0x00 , DiscRange = 0x01 ,   TReference = 1<<0 , TBlock = 1<<1 , TConstant = 1<<2 , TString = 1<<3 ,   TFlag = 1<<4 , TAddress = 1<<5 , OpAddr = 0x03 , OpDeref = 0x06 ,   OpConst1u = 0x08 , OpConst1s = 0x09 , OpConst2u = 0x0A , OpConst2s = 0x0B ,   OpConst4u = 0x0C , OpConst4s = 0x0D , OpConst8u = 0x0E , OpConst8s = 0x0F ,   OpConstu = 0x10 , OpConsts = 0x11 , OpDup = 0x12 , OpDrop = 0x13 ,   OpOver = 0x14 , OpPick = 0x15 , OpSwap = 0x16 , OpRot = 0x17 ,   OpXderef = 0x18 , OpAbs = 0x19 , OpAnd = 0x1A , OpDiv = 0x1B ,   OpMinus = 0x1C , OpMod = 0x1D , OpMul = 0x1E , OpNeg = 0x1F ,   OpNot = 0x20 , OpOr = 0x21 , OpPlus = 0x22 , OpPlusUconst = 0x23 ,   OpShl = 0x24 , OpShr = 0x25 , OpShra = 0x26 , OpXor = 0x27 ,   OpSkip = 0x2F , OpBra = 0x28 , OpEq = 0x29 , OpGe = 0x2A ,   OpGt = 0x2B , OpLe = 0x2C , OpLt = 0x2D , OpNe = 0x2E ,   OpLit0 = 0x30 , OpReg0 = 0x50 , OpBreg0 = 0x70 , OpRegx = 0x90 ,   OpFbreg = 0x91 , OpBregx = 0x92 , OpPiece = 0x93 , OpDerefSize = 0x94 ,   OpXderefSize = 0x95 , OpNop = 0x96 , OpPushObjAddr = 0x97 , OpCall2 = 0x98 ,   OpCall4 = 0x99 , OpCallRef = 0x9A }
enum	{   RuleUndef , RuleSame , RuleCfaOffset , RuleRegister ,   RuleRegOff , RuleLocation }

Functions
Dwarf *	dwarfopen (struct _Pe *elf)
void	dwarfclose (Dwarf *)
int	dwarfaddrtounit (Dwarf *, ulong, ulong *)
int	dwarflookupfn (Dwarf *, ulong, ulong, DwarfSym *)
int	dwarflookupname (Dwarf *, char *, DwarfSym *)
int	dwarflookupnameinunit (Dwarf *, ulong, char *, DwarfSym *)
int	dwarflookupsubname (Dwarf *, DwarfSym *, char *, DwarfSym *)
int	dwarflookuptag (Dwarf *, ulong, ulong, DwarfSym *)
int	dwarfenumunit (Dwarf *, ulong, DwarfSym *)
int	dwarfseeksym (Dwarf *, ulong, ulong, DwarfSym *)
int	dwarfenum (Dwarf *, DwarfSym *)
int	dwarfnextsym (Dwarf *, DwarfSym *)
int	dwarfnextsymat (Dwarf *, DwarfSym *parent, DwarfSym *child)
int	dwarfpctoline (Dwarf *, DwarfSym *proc, ulong, char **, char **, ulong *)
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	dwarfget2 (DwarfBuf *)
ulong	dwarfget4 (DwarfBuf *)
uvlong	dwarfget8 (DwarfBuf *)
ulong	dwarfget128 (DwarfBuf *)
long	dwarfget128s (DwarfBuf *)
ulong	dwarfgetaddr (DwarfBuf *)
int	dwarfgetn (DwarfBuf *, uchar *, int)
uchar *	dwarfgetnref (DwarfBuf *, ulong)
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)
DwarfAbbrev *	dwarfgetabbrev (Dwarf *, ulong, ulong)
int	dwarfgetinfounit (Dwarf *, ulong, DwarfBlock *)
void	dwarfdumpsym (Dwarf *d, DwarfSym *s)

Macro Definition Documentation

MAXIMUM_DWARF_NAME_SIZE

#define MAXIMUM_DWARF_NAME_SIZE   64

Definition at line 488 of file dwarf.h.

Typedef Documentation

Dwarf

typedef struct Dwarf Dwarf

Definition at line 3 of file dwarf.h.

DwarfAbbrev

typedef struct DwarfAbbrev DwarfAbbrev

Definition at line 430 of file dwarf.h.

DwarfAttr

typedef struct DwarfAttr DwarfAttr

Definition at line 431 of file dwarf.h.

DwarfAttrs

typedef struct DwarfAttrs DwarfAttrs

Definition at line 4 of file dwarf.h.

DwarfBlock

typedef struct DwarfBlock DwarfBlock

Definition at line 5 of file dwarf.h.

DwarfBuf

typedef struct DwarfBuf DwarfBuf

Definition at line 6 of file dwarf.h.

DwarfExpr

typedef struct DwarfExpr DwarfExpr

Definition at line 7 of file dwarf.h.

DwarfParam

typedef struct DwarfParam DwarfParam

Definition at line 10 of file dwarf.h.

DwarfStack

typedef struct DwarfStack DwarfStack

Definition at line 9 of file dwarf.h.

DwarfSym

typedef struct DwarfSym DwarfSym

Definition at line 8 of file dwarf.h.

DwarfVal

typedef union DwarfVal DwarfVal

Definition at line 11 of file dwarf.h.

Enumeration Type Documentation

anonymous enum

anonymous enum

Enumerator
TagArrayType
TagClassType
TagEntryPoint
TagEnumerationType
TagFormalParameter
TagImportedDeclaration
TagLabel
TagLexDwarfBlock
TagMember
TagPointerType
TagReferenceType
TagCompileUnit
TagStringType
TagStructType
TagSubroutineType
TagTypedef
TagUnionType
TagUnspecifiedParameters
TagVariant
TagCommonDwarfBlock
TagCommonInclusion
TagInheritance
TagInlinedSubroutine
TagModule
TagPtrToMemberType
TagSetType
TagSubrangeType
TagWithStmt
TagAccessDeclaration
TagBaseType
TagCatchDwarfBlock
TagConstType
TagConstant
TagEnumerator
TagFileType
TagFriend
TagNamelist
TagNamelistItem
TagPackedType
TagSubprogram
TagTemplateTypeParameter
TagTemplateValueParameter
TagThrownType
TagTryDwarfBlock
TagVariantPart
TagVariable
TagVolatileType
TagDwarfProcedure
TagRestrictType
TagInterfaceType
TagNamespace
TagImportedModule
TagUnspecifiedType
TagPartialUnit
TagImportedUnit
TagMutableType
TypeAddress
TypeBoolean
TypeComplexFloat
TypeFloat
TypeSigned
TypeSignedChar
TypeUnsigned
TypeUnsignedChar
TypeImaginaryFloat
AccessPublic
AccessProtected
AccessPrivate
VisLocal
VisExported
VisQualified
VirtNone
VirtVirtual
VirtPureVirtual
LangC89
LangC
LangAda83
LangCplusplus
LangCobol74
LangCobol85
LangFortran77
LangFortran90
LangPascal83
LangModula2
LangJava
LangC99
LangAda95
LangFortran95
LangPLI
IdCaseSensitive
IdCaseUpper
IdCaseLower
IdCaseInsensitive
CallingNormal
CallingProgram
CallingNocall
InNone
InInlined
InDeclaredNotInlined
InDeclaredInlined
OrderRowMajor
OrderColumnMajor
DiscLabel
DiscRange
TReference
TBlock
TConstant
TString
TFlag
TAddress
OpAddr
OpDeref
OpConst1u
OpConst1s
OpConst2u
OpConst2s
OpConst4u
OpConst4s
OpConst8u
OpConst8s
OpConstu
OpConsts
OpDup
OpDrop
OpOver
OpPick
OpSwap
OpRot
OpXderef
OpAbs
OpAnd
OpDiv
OpMinus
OpMod
OpMul
OpNeg
OpNot
OpOr
OpPlus
OpPlusUconst
OpShl
OpShr
OpShra
OpXor
OpSkip
OpBra
OpEq
OpGe
OpGt
OpLe
OpLt
OpNe
OpLit0
OpReg0
OpBreg0
OpRegx
OpFbreg
OpBregx
OpPiece
OpDerefSize
OpXderefSize
OpNop
OpPushObjAddr
OpCall2
OpCall4
OpCallRef

Definition at line 13 of file dwarf.h.

{
    TagArrayType = 0x01,
    TagClassType = 0x02,
    TagEntryPoint = 0x03,
    TagEnumerationType = 0x04,
    TagFormalParameter = 0x05,
    TagImportedDeclaration = 0x08,
    TagLabel = 0x0A,
    TagLexDwarfBlock = 0x0B,
    TagMember = 0x0D,
    TagPointerType = 0x0F,
    TagReferenceType = 0x10,
    TagCompileUnit = 0x11,
    TagStringType = 0x12,
    TagStructType = 0x13,
    TagSubroutineType = 0x15,
    TagTypedef = 0x16,
    TagUnionType = 0x17,
    TagUnspecifiedParameters = 0x18,
    TagVariant = 0x19,
    TagCommonDwarfBlock = 0x1A,
    TagCommonInclusion = 0x1B,
    TagInheritance = 0x1C,
    TagInlinedSubroutine = 0x1D,
    TagModule = 0x1E,
    TagPtrToMemberType = 0x1F,
    TagSetType = 0x20,
    TagSubrangeType = 0x21,
    TagWithStmt = 0x22,
    TagAccessDeclaration = 0x23,
    TagBaseType = 0x24,
    TagCatchDwarfBlock = 0x25,
    TagConstType = 0x26,
    TagConstant = 0x27,
    TagEnumerator = 0x28,
    TagFileType = 0x29,
    TagFriend = 0x2A,
    TagNamelist = 0x2B,
    TagNamelistItem = 0x2C,
    TagPackedType = 0x2D,
    TagSubprogram = 0x2E,
    TagTemplateTypeParameter = 0x2F,
    TagTemplateValueParameter = 0x30,
    TagThrownType = 0x31,
    TagTryDwarfBlock = 0x32,
    TagVariantPart = 0x33,
    TagVariable = 0x34,
    TagVolatileType = 0x35,
    TagDwarfProcedure = 0x36,
    TagRestrictType = 0x37,
    TagInterfaceType = 0x38,
    TagNamespace = 0x39,
    TagImportedModule = 0x3A,
    TagUnspecifiedType = 0x3B,
    TagPartialUnit = 0x3C,
    TagImportedUnit = 0x3D,
    TagMutableType = 0x3E,
 
    TypeAddress = 0x01,
    TypeBoolean = 0x02,
    TypeComplexFloat = 0x03,
    TypeFloat = 0x04,
    TypeSigned = 0x05,
    TypeSignedChar = 0x06,
    TypeUnsigned = 0x07,
    TypeUnsignedChar = 0x08,
    TypeImaginaryFloat = 0x09,
 
    AccessPublic = 0x01,
    AccessProtected = 0x02,
    AccessPrivate = 0x03,
 
    VisLocal = 0x01,
    VisExported = 0x02,
    VisQualified = 0x03,
 
    VirtNone = 0x00,
    VirtVirtual = 0x01,
    VirtPureVirtual = 0x02,
 
    LangC89 = 0x0001,
    LangC = 0x0002,
    LangAda83 = 0x0003,
    LangCplusplus = 0x0004,
    LangCobol74 = 0x0005,
    LangCobol85 = 0x0006,
    LangFortran77 = 0x0007,
    LangFortran90 = 0x0008,
    LangPascal83 = 0x0009,
    LangModula2 = 0x000A,
    LangJava = 0x000B,
    LangC99 = 0x000C,
    LangAda95 = 0x000D,
    LangFortran95 = 0x000E,
    LangPLI = 0x000F,
    /* 0x8000-0xFFFF reserved */
 
    IdCaseSensitive = 0x00,
    IdCaseUpper = 0x01,
    IdCaseLower = 0x02,
    IdCaseInsensitive = 0x03,
 
    CallingNormal = 0x01,
    CallingProgram = 0x02,
    CallingNocall = 0x03,
    /* 0x40-0xFF reserved */
 
    InNone = 0x00,
    InInlined = 0x01,
    InDeclaredNotInlined = 0x02,
    InDeclaredInlined = 0x03,
 
    OrderRowMajor = 0x00,
    OrderColumnMajor = 0x01,
 
    DiscLabel = 0x00,
    DiscRange = 0x01,
 
    TReference = 1<<0,
    TBlock = 1<<1,
    TConstant = 1<<2,
    TString = 1<<3,
    TFlag = 1<<4,
    TAddress = 1<<5,
 
    OpAddr = 0x03,  /* 1 op, const addr */
    OpDeref = 0x06,
    OpConst1u = 0x08,   /* 1 op, 1 byte const */
    OpConst1s = 0x09,   /*  " signed */
    OpConst2u = 0x0A,   /* 1 op, 2 byte const  */
    OpConst2s = 0x0B,   /*  " signed */
    OpConst4u = 0x0C,   /* 1 op, 4 byte const */
    OpConst4s = 0x0D,   /*  " signed */
    OpConst8u = 0x0E,   /* 1 op, 8 byte const */
    OpConst8s = 0x0F,   /*  " signed */
    OpConstu = 0x10,    /* 1 op, LEB128 const */
    OpConsts = 0x11,    /*  " signed */
    OpDup = 0x12,
    OpDrop = 0x13,
    OpOver = 0x14,
    OpPick = 0x15,      /* 1 op, 1 byte stack index */
    OpSwap = 0x16,
    OpRot = 0x17,
    OpXderef = 0x18,
    OpAbs = 0x19,
    OpAnd = 0x1A,
    OpDiv = 0x1B,
    OpMinus = 0x1C,
    OpMod = 0x1D,
    OpMul = 0x1E,
    OpNeg = 0x1F,
    OpNot = 0x20,
    OpOr = 0x21,
    OpPlus = 0x22,
    OpPlusUconst = 0x23,    /* 1 op, ULEB128 addend */
    OpShl = 0x24,
    OpShr = 0x25,
    OpShra = 0x26,
    OpXor = 0x27,
    OpSkip = 0x2F,      /* 1 op, signed 2-byte constant */
    OpBra = 0x28,       /* 1 op, signed 2-byte constant */
    OpEq = 0x29,
    OpGe = 0x2A,
    OpGt = 0x2B,
    OpLe = 0x2C,
    OpLt = 0x2D,
    OpNe = 0x2E,
    OpLit0 = 0x30,
        /* OpLitN = OpLit0 + N for N = 0..31 */
    OpReg0 = 0x50,
        /* OpRegN = OpReg0 + N for N = 0..31 */
    OpBreg0 = 0x70, /* 1 op, signed LEB128 constant */
        /* OpBregN = OpBreg0 + N for N = 0..31 */
    OpRegx = 0x90,  /* 1 op, ULEB128 register */
    OpFbreg = 0x91, /* 1 op, SLEB128 offset */
    OpBregx = 0x92, /* 2 op, ULEB128 reg, SLEB128 off */
    OpPiece = 0x93, /* 1 op, ULEB128 size of piece */
    OpDerefSize = 0x94, /* 1-byte size of data retrieved */
    OpXderefSize = 0x95,    /* 1-byte size of data retrieved */
    OpNop = 0x96,
    /* next four new in Dwarf v3 */
    OpPushObjAddr = 0x97,
    OpCall2 = 0x98, /* 2-byte offset of DIE */
    OpCall4 = 0x99, /* 4-byte offset of DIE */
    OpCallRef = 0x9A    /* 4- or 8- byte offset of DIE */
    /* 0xE0-0xFF reserved for user-specific */
};

anonymous enum

anonymous enum

Enumerator
RuleUndef
RuleSame
RuleCfaOffset
RuleRegister
RuleRegOff
RuleLocation

Definition at line 368 of file dwarf.h.

{
    RuleUndef,
    RuleSame,
    RuleCfaOffset,
    RuleRegister,
    RuleRegOff,
    RuleLocation
};

Function Documentation

dwarfaddrtounit()

int dwarfaddrtounit	(	Dwarf *	d,
		ulong	addr,
		ulong *	unit
	)

Definition at line 16 of file dwarfaranges.c.

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

dwarfargvalue()

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

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().

dwarfclose()

void dwarfclose

(

Dwarf *

d

)

Definition at line 57 of file dwarfopen.c.

{
    free(d->abbrev.data);
    free(d->aranges.data);
    free(d->frame.data);
    free(d->line.data);
    free(d->pubnames.data);
    free(d->ranges.data);
    free(d->str.data);
    free(d->info.data);
    pefree(d->pe);
    free(d);
}

dwarfcomputecfa()

int dwarfcomputecfa	(	Dwarf *	d,
		DwarfExpr *	cfa,
		PROSSYM_REGISTERS	registers,
		ulong *	cfaLocation
	)

Definition at line 404 of file dwarfcfa.c.

{
    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;
}

Referenced by dwarfregunwind(), and 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);
    }
}

dwarfenum()

int dwarfenum	(	Dwarf *	d,
		DwarfSym *	s
	)

Definition at line 241 of file dwarfinfo.c.

{
    if(dwarfenumunit(d, 0, s) < 0)
        return -1;
    s->allunits = 1;
    return 0;
}

dwarfenumunit()

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

Definition at line 201 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->nextunit = unit + 4 + len;
 
    if(s->b.ep - s->b.p < len){
    badheader:
        werrstr("bad dwarf unit header at unit 0x%lux", unit);
        return -1;
    }
    s->b.ep = s->b.p+len;
    if((i=dwarfget2(&s->b)) != 2)
        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;
    s->unit = unit;
    s->depth = 0;
    return 0;
}

Referenced by dwarfargvalue(), dwarfenum(), dwarflookupfn(), dwarflookupnameinunit(), dwarflookuptag(), dwarfnextsym(), and dwarfseeksym().

dwarfget1()

ulong dwarfget1

(

DwarfBuf *

b

)

Definition at line 17 of file dwarfget.c.

{
    if(b->p==nil || b->p+1 > b->ep){
        b->p = nil;
        return 0;
    }
    return *b->p++;
}

Referenced by dwarfgetaddr().

dwarfget128()

ulong dwarfget128

(

DwarfBuf *

b

)

Definition at line 152 of file dwarfget.c.

{
    static int nbad;
    ulong c, d;
 
    if(b->p == nil)
        return 0;
    c = *b->p++;
    if(!(c&0x80))
{n1++;
        return c;
}
    c &= ~0x80;
    d = *b->p++;
    c |= (d&0x7F)<<7;
    if(!(d&0x80))
{n2++;
        return c;
}
    d = *b->p++;
    c |= (d&0x7F)<<14;
    if(!(d&0x80))
{n3++;
        return c;
}
    d = *b->p++;
    c |= (d&0x7F)<<21;
    if(!(d&0x80))
{n4++;
        return c;
}
    d = *b->p++;
    c |= (d&0x7F)<<28;
    if(!(d&0x80))
{n5++;
        return c;
}
    while(b->p<b->ep && *b->p&0x80)
        b->p++;
    if(++nbad == 1)
        werrstr("dwarf: overflow during parsing of uleb128 integer\n");
    return c;
}

dwarfget128s()

long dwarfget128s

(

DwarfBuf *

b

)

Definition at line 197 of file dwarfget.c.

{
    int nb, c;
    ulong v;
    static int nbad;
 
    v = 0;
    nb = 0;
    if(b->p==nil)
        return 0;
    while(b->p<b->ep){
        c = *b->p++;
        v |= (c & 0x7F)<<nb;
        nb += 7;
        if(!(c&0x80))
            break;
    }
    if(v&(1<<(nb-1)))
        v |= ~(((ulong)1<<nb)-1);
    if(nb > 8*sizeof(ulong)){
        if(0)
        if(++nbad == 1)
            werrstr("dwarf: overflow during parsing of sleb128 integer: got %d bits", nb);
    }
    return v;
}

dwarfget2()

ulong dwarfget2

(

DwarfBuf *

b

)

Definition at line 81 of file dwarfget.c.

{
    ulong v;
 
    if(b->p==nil || b->p+2 > b->ep){
        b->p = nil;
        return 0;
    }
    v = b->d->pe->e2(b->p);
    b->p += 2;
    return v;
}

Referenced by dwarfgetaddr().

dwarfget4()

ulong dwarfget4

(

DwarfBuf *

b

)

Definition at line 95 of file dwarfget.c.

{
    ulong v;
 
    if(b->p==nil || b->p+4 > b->ep){
        b->p = nil;
        return 0;
    }
    v = b->d->pe->e4(b->p);
    b->p += 4;
    return v;
}

Referenced by dwarfgetaddr().

dwarfget8()

uvlong dwarfget8

(

DwarfBuf *

b

)

Definition at line 109 of file dwarfget.c.

{
    uvlong v;
 
    if(b->p==nil || b->p+8 > b->ep){
        b->p = nil;
        return 0;
    }
    v = b->d->pe->e8(b->p);
    b->p += 8;
    return v;
}

Referenced by dwarfgetaddr().

dwarfgetabbrev()

DwarfAbbrev * dwarfgetabbrev	(	Dwarf *	d,
		ulong	off,
		ulong	num
	)

Definition at line 128 of file dwarfabbrev.c.

{
    DwarfAbbrev *a;
    int na;
 
    if((na = loadabbrevs(d, off, &a)) < 0){
        werrstr("loadabbrevs: %r");
        return nil;
    }
    return findabbrev(a, na, num);
}

dwarfgetaddr()

ulong dwarfgetaddr

(

DwarfBuf *

b

)

Definition at line 123 of file dwarfget.c.

{
    static int nbad;
 
    if(b->addrsize == 0)
        b->addrsize = b->d->addrsize;
 
    switch(b->addrsize){
    case 1:
        return dwarfget1(b);
    case 2:
        return dwarfget2(b);
    case 4:
        return dwarfget4(b);
    case 8:
        return dwarfget8(b);
    default:
        if(++nbad == 1)
            werrstr("dwarf: unexpected address size %lud in dwarfgetaddr\n", b->addrsize);
        b->p = nil;
        return 0;
    }
}

dwarfgetarg()

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

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().

dwarfgetinfounit()

int dwarfgetinfounit	(	Dwarf *	,
		ulong	,
		DwarfBlock *
	)

dwarfgetn()

int dwarfgetn	(	DwarfBuf *	b,
		uchar *	a,
		int	n
	)

Definition at line 27 of file dwarfget.c.

{
    if(b->p==nil || b->p+n > b->ep){
        b->p = nil;
        memset(a, 0, n);
        return -1;
    }
    memmove(a, b->p, n);
    b->p += n;
    return 0;
}

dwarfgetnref()

uchar * dwarfgetnref	(	DwarfBuf *	b,
		ulong	n
	)

Definition at line 40 of file dwarfget.c.

{
    uchar *p;
 
    if(b->p==nil || b->p+n > b->ep){
        b->p = nil;
        return nil;
    }
    p = b->p;
    b->p += n;
    return p;
}

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().

dwarfgetstring()

char * dwarfgetstring

(

DwarfBuf *

b

)

Definition at line 54 of file dwarfget.c.

{
    char *s;
 
    if(b->p == nil)
        return nil;
    s = (char*)b->p;
    while(b->p < b->ep && *b->p)
        b->p++;
    if(b->p >= b->ep){
        b->p = nil;
        return nil;
    }
    b->p++;
    return s;
}

dwarfgettype()

int dwarfgettype	(	Dwarf *	d,
		DwarfSym *	param,
		DwarfSym *	type
	)

dwarflookupfn()

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

Definition at line 181 of file dwarfinfo.c.

{
    if(dwarfenumunit(d, unit, s) < 0)
        return -1;
 
    if(dwarfnextsymat(d, s, 0) != 1)
        return -1;
    /* s is now the CompileUnit */
 
    while(dwarfnextsymat(d, s, 1) == 1){
        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;
}

dwarflookupname()

int dwarflookupname	(	Dwarf *	d,
		char *	name,
		DwarfSym *	sym
	)

Definition at line 67 of file dwarfpubnames.c.

{
    return _dwarfnametounit(d, name, &d->pubnames, sym);
}

dwarflookupnameinunit()

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

Definition at line 125 of file dwarfinfo.c.

{
    if(dwarfenumunit(d, unit, s) < 0)
        return -1;
 
    dwarfnextsymat(d, s, 0);    /* s is now the CompileUnit */
    while(dwarfnextsymat(d, s, 1) == 1)
        if(s->attrs.name && strcmp(s->attrs.name, name) == 0)
            return 0;
    werrstr("symbol '%s' not found", name);
    return -1;
}

dwarflookupsubname()

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

Definition at line 140 of file dwarfinfo.c.

{
    *s = *parent;
    while(dwarfnextsymat(d, s, parent->depth+1))
        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 151 of file dwarfinfo.c.

{
    if(dwarfenumunit(d, unit, s) < 0) {
        return -1;
    }
 
    dwarfnextsymat(d, s, 0);    /* s is now the CompileUnit */
    if(s->attrs.tag == tag) {
        return 0;
    }
    while(dwarfnextsymat(d, s, 1) == 1)
        if(s->attrs.tag == tag) {
            return 0;
        }
    werrstr("symbol with tag 0x%lux not found", tag);
    return -1;
}

dwarfnextsym()

int dwarfnextsym	(	Dwarf *	d,
		DwarfSym *	s
	)

Definition at line 250 of file dwarfinfo.c.

{
    ulong num;
    DwarfAbbrev *a;
 
    if(s->attrs.haskids)
        s->depth++;
top:
    if(s->b.p >= s->b.ep){
        if(s->allunits && s->nextunit < d->info.len){
            if(dwarfenumunit(d, s->nextunit, s) < 0) {
                return -1;
            }
            s->allunits = 1;
            goto top;
        }
        return 0;
    }
 
    s->uoff = s->b.p - (d->info.data+s->unit);
    num = dwarfget128(&s->b);
    if(num == 0){
        if(s->depth == 0) {
            return 0;
        }
        if(s->depth > 0)
            s->depth--;
        goto top;
    }
 
    a = dwarfgetabbrev(d, s->aoff, num);
    if(a == nil){
        werrstr("getabbrev %ud %ud for %ud,%ud: %r\n", s->aoff, num, s->unit, s->uoff);
        return -1;
    }
    if(parseattrs(&s->b, s->unit, a, &s->attrs) < 0) {
        return -1;
    }
    return 1;
}

Referenced by dwarfenumunit(), dwarflookupchildtag(), dwarflookuptag(), dwarfnextsym(), and dwarfnextsymat().

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);
}

dwarfopen()

Dwarf * dwarfopen

(

struct _Pe *

elf

)

Definition at line 16 of file dwarfopen.c.

{
    Dwarf *d;
 
    if(pe == nil){
        werrstr("nil pe passed to dwarfopen");
        return nil;
    }
 
    d = mallocz(sizeof(Dwarf), 1);
    if(d == nil)
        return nil;
 
    d->pe = pe;
    if(pe->loadsection(pe, ".debug_abbrev", &d->abbrev) < 0
    || pe->loadsection(pe, ".debug_aranges", &d->aranges) < 0
    || pe->loadsection(pe, ".debug_line", &d->line) < 0
    || pe->loadsection(pe, ".debug_pubnames", &d->pubnames) < 0
    || pe->loadsection(pe, ".debug_info", &d->info) < 0)
        goto err;
    pe->loadsection(pe, ".debug_frame", &d->frame);
    pe->loadsection(pe, ".debug_ranges", &d->ranges);
    pe->loadsection(pe, ".debug_str", &d->str);
 
    return d;
 
err:
    DPRINT("Failed to open dwarf\n");
    free(d->abbrev.data);
    free(d->aranges.data);
    free(d->frame.data);
    free(d->line.data);
    free(d->pubnames.data);
    free(d->ranges.data);
    free(d->str.data);
    free(d->info.data);
    free(d);
    return nil;
}

dwarfpctoline()

int dwarfpctoline	(	Dwarf *	d,
		DwarfSym *	proc,
		ulong	pc,
		char **	file,
		char **	function,
		ulong *	line
	)

Definition at line 41 of file dwarfpc.c.

{
    char *cdir;
    uchar *prog, *opcount, *end, *dirs;
    ulong off, unit, len, vers, x, start, lastline;
    int i, first, firstline, op, a, l, quantum, isstmt, linebase, linerange, opcodebase, nf;
    char *files, *s;
    DwarfBuf b;
    DwarfSym sym;
    State emit, cur, reset;
    char **f, **newf;
 
    f = nil;
    memset(proc, 0, sizeof(*proc));
 
    int runit = dwarfaddrtounit(d, pc, &unit);
    if (runit < 0)
        return -1;
    int rtag = dwarflookuptag(d, unit, TagCompileUnit, &sym);
    if (rtag < 0)
        return -1;
 
    if(!sym.attrs.have.stmtlist){
        werrstr("no line mapping information for 0x%x", pc);
        return -1;
    }
    off = sym.attrs.stmtlist;
    if(off >= d->line.len){
        werrstr("bad stmtlist");
        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 (!cdir && dwarfdir)
        cdir = dwarfdir;
 
    char *filefull = malloc(strlen(cdir) + strlen(*file) + 2);
    strcpy(filefull, cdir);
    strcat(filefull, "/");
    strcat(filefull, *file);
    *file = filefull;
 
    *function = nil;
    lastline = 0;
 
    runit = dwarfaddrtounit(d, pc, &unit);
    if (runit == 0) {
        DwarfSym compunit = { };
        int renum = dwarfenumunit(d, unit, &compunit);
        if (renum < 0)
            return -1;
        renum = dwarfnextsymat(d, &compunit, proc);
        while (renum == 0) {
            if (proc->attrs.tag == TagSubprogram &&
                proc->attrs.have.name)
            {
                if (proc->attrs.lowpc <= pc && proc->attrs.highpc > pc) {
                    *function = malloc(strlen(proc->attrs.name)+1);
                    strcpy(*function, proc->attrs.name);
                    goto done;
                }
            }
            renum = dwarfnextsym(d, proc);
        }
    }
 
    // Next search by declaration
    runit = dwarfaddrtounit(d, pc, &unit);
    if (runit == 0) {
        DwarfSym compunit = { };
        int renum = dwarfenumunit(d, unit, &compunit);
        if (renum < 0)
            return -1;
        renum = dwarfnextsymat(d, &compunit, proc);
        while (renum == 0) {
            if (proc->attrs.tag == TagSubprogram &&
                proc->attrs.have.name &&
                proc->attrs.declfile == emit.file)
            {
                if (proc->attrs.declline <= *line &&
                    proc->attrs.declline > lastline) {
                    free(*function);
                    *function = malloc(strlen(proc->attrs.name)+1);
                    strcpy(*function, proc->attrs.name);
                    goto done;
                }
                lastline = proc->attrs.declline;
            }
            renum = dwarfnextsym(d, proc);
        }
    }
 
    /* free at last, free at last */
done:
    free(f);
    return 0;
bad:
    werrstr("corrupted line mapping for 0x%x", pc);
out:
    free(f);
    return -1;
}

dwarfregunwind()

int dwarfregunwind	(	Dwarf *	d,
		ulong	pc,
		ulong	fde,
		DwarfExpr *	cfa,
		PROSSYM_REGISTERS	registers
	)

Definition at line 419 of file dwarfcfa.c.

{
    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;
}

Referenced by RosSymGetAddressInformation().

dwarfseeksym()

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

Definition at line 170 of file dwarfinfo.c.

{
    if(dwarfenumunit(d, unit, s) < 0)
        return -1;
    s->b.p = d->info.data + unit + off;
    if(dwarfnextsymat(d, s, 0) != 1)
        return -1;
    return 0;
}