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	DwarfBuf
union	DwarfVal
struct	DwarfAttrs
struct	DwarfExpr
struct	DwarfSym
struct	DwarfAttr
struct	DwarfAbbrev
struct	Dwarf

Macros
#define	SYMBOL_SIZE   18
#define	MAXIMUM_DWARF_NAME_SIZE   64
#define	MAXIMUM_COFF_SYMBOL_LENGTH   256

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 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 *, int)
int	dwarfpctoline (Dwarf *, ulong, char **, char **, char **, char **, ulong *, ulong *, ulong *)
int	dwarfunwind (Dwarf *, ulong, DwarfExpr *, DwarfExpr *, DwarfExpr *, int)
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 *)
DwarfAbbrev *	dwarfgetabbrev (Dwarf *, ulong, ulong)
int	dwarfgetinfounit (Dwarf *, ulong, DwarfBlock *)

Variables
int	dwarf386nregs
char *	dwarf386regs []
char *	dwarf386fp

Macro Definition Documentation

MAXIMUM_COFF_SYMBOL_LENGTH

#define MAXIMUM_COFF_SYMBOL_LENGTH   256

Definition at line 471 of file dwarf.h.

MAXIMUM_DWARF_NAME_SIZE

#define MAXIMUM_DWARF_NAME_SIZE   64

Definition at line 470 of file dwarf.h.

SYMBOL_SIZE

#define SYMBOL_SIZE   18

Definition at line 469 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 416 of file dwarf.h.

DwarfAttr

typedef struct DwarfAttr DwarfAttr

Definition at line 417 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.

DwarfSym

typedef struct DwarfSym DwarfSym

Definition at line 8 of file dwarf.h.

DwarfVal

typedef union DwarfVal DwarfVal

Definition at line 9 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 11 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 356 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;
}

Referenced by dwarfpctoline(), and RosSymAggregate().

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

Referenced by RosSymDelete().

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

Referenced by main().

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 _dwarfnametounit(), and dwarfpctoline().

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 constblock(), dexec(), dwarfaddrtounit(), dwarfenumunit(), dwarfgetarg(), dwarfpctoline(), findfde(), getblock(), getuchar(), getulong(), and parseabbrevs().

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

Referenced by constblock(), dexec(), dwarfgetarg(), dwarfnextsym(), dwarfpctoline(), findfde(), getblock(), getulong(), parseabbrevs(), and parseattrs().

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

Referenced by constblock(), dexec(), dwarfgetarg(), dwarfpctoline(), findfde(), and getulong().

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 _dwarfnametounit(), constblock(), dexec(), dwarfaddrtounit(), dwarfargvalue(), dwarfenumunit(), dwarfgetarg(), dwarfpctoline(), getblock(), and getulong().

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 _dwarfnametounit(), constblock(), dexec(), dwarfaddrtounit(), dwarfargvalue(), dwarfenumunit(), dwarfgetarg(), dwarfpctoline(), findfde(), getblock(), getstring(), and getulong().

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 constblock(), and getulong().

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

Referenced by dwarfnextsym().

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

Referenced by constblock(), dexec(), dwarfaddrtounit(), dwarfpctoline(), findfde(), and getulong().

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

Referenced by dexec(), dwarfpctoline(), and getblock().

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

Referenced by _dwarfnametounit(), dwarfpctoline(), findfde(), and getstring().

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

Referenced by dwarfpctoline().

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

Referenced by RosSymAggregate().

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

Referenced by dwarfpctoline().

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 _dwarfnametounit(), dwarfpctoline(), and main().

dwarfnextsymat()

int dwarfnextsymat	(	Dwarf *	d,
		DwarfSym *	s,
		int	depth
	)

Definition at line 292 of file dwarfinfo.c.

{
    int r;
    DwarfSym t;
    uint sib;
 
    if(s->depth == depth && s->attrs.have.sibling){
        sib = s->attrs.sibling;
        if(sib < d->info.len && d->info.data+sib >= s->b.p)
            s->b.p = d->info.data+sib;
        s->attrs.haskids = 0;
    }
 
    /*
     * The funny game with t and s make sure that
     * if we get to the end of a run of a particular
     * depth, we leave s so that a call to nextsymat with depth-1
     * will actually produce the desired guy.  We could change
     * the interface to dwarfnextsym instead, but I'm scared
     * to touch it.
     */
    t = *s;
    for(;;){
        if((r = dwarfnextsym(d, &t)) != 1) {
            return r;
        }
        if(t.depth < depth){
            /* went too far - nothing to see */
            return 0;
        }
        *s = t;
        if(t.depth == depth) {
            return 1;
        }
    }
}

Referenced by dwarfgetparams(), dwarflookupchildtag(), dwarflookupfn(), dwarflookupnameinunit(), dwarflookupsubname(), dwarflookuptag(), dwarfnextsym(), dwarfpctoline(), dwarfseeksym(), and RosSymAggregate().

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

Referenced by main(), RosSymCreateFromFile(), and RosSymCreateFromMem().

dwarfpctoline()

int dwarfpctoline	(	Dwarf *	d,
		ulong	pc,
		char **	cdir,
		char **	dir,
		char **	file,
		char **	function,
		ulong *	line,
		ulong *	mtime,
		ulong *	length
	)

Definition at line 48 of file dwarfpc.c.

{
    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;
    uchar **f, **newf;
 
    f = nil;
 
    if(dwarfaddrtounit(d, pc, &unit) < 0
       || dwarflookuptag(d, unit, TagCompileUnit, &sym) < 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\n");
        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\n");
        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\n");
        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\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)
                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\n");
                    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)
                    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;
            }
        }
    }
    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;
 
bad:
    werrstr("corrupted line mapping for 0x%x", pc);
out:
    free(f);
    return -1;
}

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

Referenced by RosSymAggregate().

dwarfunwind()

int dwarfunwind	(	Dwarf *	d,
		ulong	pc,
		DwarfExpr *	cfa,
		DwarfExpr *	ra,
		DwarfExpr *	r,
		int	nr
	)

Definition at line 47 of file dwarfcfa.c.

{
    int i, ret;
    DwarfBuf fde, b;
    DwarfExpr *initr;
    State s;
 
    initr = mallocz(nr*sizeof(initr[0]), 1);
    if(initr == 0)
        return -1;
 
    memset(&s, 0, sizeof s);
    s.loc = 0;
    s.cfa = cfa;
    s.ra = ra;
    s.r = r;
    s.nr = nr;
 
    if(findfde(d, pc, &s, &fde) < 0){
        free(initr);
        return -1;
    }
 
    memset(r, 0, nr*sizeof(r[0]));
    for(i=0; i<nr; i++)
        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);
    b = s.init;
    if(dexec(&b, &s, 0) < 0)
        goto err;
 
    s.initr = initr;
    memmove(initr, r, nr*sizeof(initr[0]));
 
    if(trace) werrstr("s.loc 0x%lux pc 0x%lux\n", s.loc, pc);
    while(s.loc < pc){
        if(trace) werrstr("s.loc 0x%lux pc 0x%lux\n", s.loc, pc);
        if(dexec(&fde, &s, 1) < 0)
            goto err;
    }
    *ra = s.r[s.rareg];
 
    ret = 0;
    goto out;
 
err:
    ret = -1;
out:
    free(initr);
    for(i=0; i<s.nstack; i++)
        free(s.stack[i]);
    free(s.stack);
    return ret;
}

Referenced by dwarfregunwind(), and printrules().

Variable Documentation

dwarf386fp

char* dwarf386fp

extern

dwarf386nregs

int dwarf386nregs

extern

Definition at line 22 of file dwarf386.c.

dwarf386regs

char* dwarf386regs[]

extern

Definition at line 10 of file dwarf386.c.