rossym.h File Reference

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

Go to the source code of this file.

Classes
struct	_ROSSYM_HEADER
struct	_ROSSYM_ENTRY
struct	_ROSSYM_REGISTERS
struct	_ROSSYM_PARAMETER
struct	_ROSSYM_LINEINFO
struct	_ROSSYM_AGGREGATE_MEMBER
struct	_ROSSYM_AGGREGATE
struct	_ROSSYM_CALLBACKS
struct	_ROSSYM_INFO

Macros
#define	ROSSYM_SECTION_NAME   ".rossym"

Typedefs
typedef struct _ROSSYM_HEADER	ROSSYM_HEADER
typedef struct _ROSSYM_HEADER *	PROSSYM_HEADER
typedef struct _ROSSYM_ENTRY	ROSSYM_ENTRY
typedef struct _ROSSYM_ENTRY *	PROSSYM_ENTRY
typedef struct _ROSSYM_REGISTERS	ROSSYM_REGISTERS
typedef struct _ROSSYM_REGISTERS *	PROSSYM_REGISTERS
typedef struct _ROSSYM_PARAMETER	ROSSYM_PARAMETER
typedef struct _ROSSYM_PARAMETER *	PROSSYM_PARAMETER
typedef enum _ROSSYM_LINEINFO_FLAGS	ROSSYM_LINEINFO_FLAGS
typedef enum _ROSSYM_LINEINFO_TYPE	ROSSYM_LINEINFO_STRINGTYPE
typedef struct _ROSSYM_LINEINFO	ROSSYM_LINEINFO
typedef struct _ROSSYM_LINEINFO *	PROSSYM_LINEINFO
typedef struct _ROSSYM_AGGREGATE_MEMBER	ROSSYM_AGGREGATE_MEMBER
typedef struct _ROSSYM_AGGREGATE_MEMBER *	PROSSYM_AGGREGATE_MEMBER
typedef struct _ROSSYM_AGGREGATE	ROSSYM_AGGREGATE
typedef struct _ROSSYM_AGGREGATE *	PROSSYM_AGGREGATE
typedef struct _ROSSYM_CALLBACKS	ROSSYM_CALLBACKS
typedef struct _ROSSYM_CALLBACKS *	PROSSYM_CALLBACKS
typedef struct _ROSSYM_INFO	ROSSYM_INFO
typedef struct _ROSSYM_INFO *	PROSSYM_INFO

Enumerations
enum	_ROSSYM_REGNAME {   ROSSYM_X86_EAX = 0 , ROSSYM_X86_ECX , ROSSYM_X86_EDX , ROSSYM_X86_EBX ,   ROSSYM_X86_ESP , ROSSYM_X86_EBP , ROSSYM_X86_ESI , ROSSYM_X86_EDI ,   ROSSYM_X64_RAX = 0 , ROSSYM_X64_RDX , ROSSYM_X64_RCX , ROSSYM_X64_RBX ,   ROSSYM_X64_RSI , ROSSYM_X64_RDI , ROSSYM_X64_RBP , ROSSYM_X64_RSP ,   Rossym_X64_R8 , ROSSYM_X64_R9 , ROSSYM_X64_R10 , ROSSYM_X64_R11 ,   ROSSYM_X64_R12 , ROSSYM_X64_R13 , ROSSYM_X64_R14 , ROSSYM_X64_R15 }
enum	_ROSSYM_LINEINFO_FLAGS { ROSSYM_LINEINFO_HAS_REGISTERS = 1 }
enum	_ROSSYM_LINEINFO_TYPE {   ROSSYM_LINEINFO_UNKNOWN , ROSSYM_LINEINFO_NARROW_STRING , ROSSYM_LINEINFO_WIDE_STRING , ROSSYM_LINEINFO_ANSI_STRING ,   ROSSYM_LINEINFO_UNICODE_STRING , ROSSYM_LINEINFO_HANDLE }

Functions
VOID	RosSymInit (PROSSYM_CALLBACKS Callbacks)
VOID	RosSymInitKernelMode (VOID)
VOID	RosSymInitUserMode (VOID)
BOOLEAN	RosSymCreateFromRaw (PVOID RawData, ULONG_PTR DataSize, PROSSYM_INFO *RosSymInfo)
BOOLEAN	RosSymCreateFromMem (PVOID ImageStart, ULONG_PTR ImageSize, PROSSYM_INFO *RosSymInfo)
BOOLEAN	RosSymCreateFromFile (PVOID FileContext, PROSSYM_INFO *RosSymInfo)
ULONG	RosSymGetRawDataLength (PROSSYM_INFO RosSymInfo)
VOID	RosSymGetRawData (PROSSYM_INFO RosSymInfo, PVOID RawData)
BOOLEAN	RosSymGetAddressInformation (PROSSYM_INFO RosSymInfo, ULONG_PTR RelativeAddress, ULONG *LineNumber, char *FileName, char *FunctionName)
VOID	RosSymFreeInfo (PROSSYM_LINEINFO RosSymLineInfo)
VOID	RosSymDelete (PROSSYM_INFO RosSymInfo)
BOOLEAN	RosSymAggregate (PROSSYM_INFO RosSymInfo, PCHAR Type, PROSSYM_AGGREGATE Aggregate)
VOID	RosSymFreeAggregate (PROSSYM_AGGREGATE Aggregate)

Macro Definition Documentation

ROSSYM_SECTION_NAME

#define ROSSYM_SECTION_NAME   ".rossym"

Definition at line 13 of file rossym.h.

Typedef Documentation

PROSSYM_AGGREGATE

typedef struct _ROSSYM_AGGREGATE * PROSSYM_AGGREGATE

PROSSYM_AGGREGATE_MEMBER

typedef struct _ROSSYM_AGGREGATE_MEMBER * PROSSYM_AGGREGATE_MEMBER

PROSSYM_CALLBACKS

typedef struct _ROSSYM_CALLBACKS * PROSSYM_CALLBACKS

PROSSYM_ENTRY

typedef struct _ROSSYM_ENTRY * PROSSYM_ENTRY

PROSSYM_HEADER

typedef struct _ROSSYM_HEADER * PROSSYM_HEADER

PROSSYM_INFO

typedef struct _ROSSYM_INFO * PROSSYM_INFO

PROSSYM_LINEINFO

typedef struct _ROSSYM_LINEINFO * PROSSYM_LINEINFO

PROSSYM_PARAMETER

typedef struct _ROSSYM_PARAMETER * PROSSYM_PARAMETER

PROSSYM_REGISTERS

typedef struct _ROSSYM_REGISTERS * PROSSYM_REGISTERS

ROSSYM_AGGREGATE

typedef struct _ROSSYM_AGGREGATE ROSSYM_AGGREGATE

ROSSYM_AGGREGATE_MEMBER

typedef struct _ROSSYM_AGGREGATE_MEMBER ROSSYM_AGGREGATE_MEMBER

ROSSYM_CALLBACKS

typedef struct _ROSSYM_CALLBACKS ROSSYM_CALLBACKS

ROSSYM_ENTRY

typedef struct _ROSSYM_ENTRY ROSSYM_ENTRY

ROSSYM_HEADER

typedef struct _ROSSYM_HEADER ROSSYM_HEADER

ROSSYM_INFO

typedef struct _ROSSYM_INFO ROSSYM_INFO

ROSSYM_LINEINFO

typedef struct _ROSSYM_LINEINFO ROSSYM_LINEINFO

ROSSYM_LINEINFO_FLAGS

typedef enum _ROSSYM_LINEINFO_FLAGS ROSSYM_LINEINFO_FLAGS

ROSSYM_LINEINFO_STRINGTYPE

typedef enum _ROSSYM_LINEINFO_TYPE ROSSYM_LINEINFO_STRINGTYPE

ROSSYM_PARAMETER

typedef struct _ROSSYM_PARAMETER ROSSYM_PARAMETER

ROSSYM_REGISTERS

typedef struct _ROSSYM_REGISTERS ROSSYM_REGISTERS

Enumeration Type Documentation

_ROSSYM_LINEINFO_FLAGS

enum _ROSSYM_LINEINFO_FLAGS

Enumerator
ROSSYM_LINEINFO_HAS_REGISTERS

Definition at line 70 of file rossym.h.

                                    {
  ROSSYM_LINEINFO_HAS_REGISTERS = 1
} ROSSYM_LINEINFO_FLAGS;

_ROSSYM_LINEINFO_TYPE

enum _ROSSYM_LINEINFO_TYPE

Enumerator
ROSSYM_LINEINFO_UNKNOWN
ROSSYM_LINEINFO_NARROW_STRING
ROSSYM_LINEINFO_WIDE_STRING
ROSSYM_LINEINFO_ANSI_STRING
ROSSYM_LINEINFO_UNICODE_STRING
ROSSYM_LINEINFO_HANDLE

Definition at line 74 of file rossym.h.

                                   {
  ROSSYM_LINEINFO_UNKNOWN,
  ROSSYM_LINEINFO_NARROW_STRING,
  ROSSYM_LINEINFO_WIDE_STRING,
  ROSSYM_LINEINFO_ANSI_STRING,
  ROSSYM_LINEINFO_UNICODE_STRING,
  ROSSYM_LINEINFO_HANDLE
} ROSSYM_LINEINFO_STRINGTYPE;

_ROSSYM_REGNAME

enum _ROSSYM_REGNAME

Enumerator
ROSSYM_X86_EAX
ROSSYM_X86_ECX
ROSSYM_X86_EDX
ROSSYM_X86_EBX
ROSSYM_X86_ESP
ROSSYM_X86_EBP
ROSSYM_X86_ESI
ROSSYM_X86_EDI
ROSSYM_X64_RAX
ROSSYM_X64_RDX
ROSSYM_X64_RCX
ROSSYM_X64_RBX
ROSSYM_X64_RSI
ROSSYM_X64_RDI
ROSSYM_X64_RBP
ROSSYM_X64_RSP
Rossym_X64_R8
ROSSYM_X64_R9
ROSSYM_X64_R10
ROSSYM_X64_R11
ROSSYM_X64_R12
ROSSYM_X64_R13
ROSSYM_X64_R14
ROSSYM_X64_R15

Definition at line 33 of file rossym.h.

                     {
    ROSSYM_X86_EAX = 0,
    ROSSYM_X86_ECX,
    ROSSYM_X86_EDX,
    ROSSYM_X86_EBX,
    ROSSYM_X86_ESP,
    ROSSYM_X86_EBP,
    ROSSYM_X86_ESI,
    ROSSYM_X86_EDI,
 
    ROSSYM_X64_RAX = 0,
    ROSSYM_X64_RDX,
    ROSSYM_X64_RCX,
    ROSSYM_X64_RBX,
    ROSSYM_X64_RSI,
    ROSSYM_X64_RDI,
    ROSSYM_X64_RBP,
    ROSSYM_X64_RSP,
    Rossym_X64_R8,
    ROSSYM_X64_R9,
    ROSSYM_X64_R10,
    ROSSYM_X64_R11,
    ROSSYM_X64_R12,
    ROSSYM_X64_R13,
    ROSSYM_X64_R14,
    ROSSYM_X64_R15
};

Function Documentation

RosSymAggregate()

BOOLEAN RosSymAggregate	(	PROSSYM_INFO	RosSymInfo,
		PCHAR	Type,
		PROSSYM_AGGREGATE	Aggregate
	)

Definition at line 137 of file find.c.

{
    char *tchar;
    ulong unit, typeoff = 0;
    DwarfSym type = { };
    // Get the first unit
    if (dwarfaddrtounit(RosSymInfo, RosSymInfo->pe->codestart + RosSymInfo->pe->imagebase, &unit) == -1)
        return FALSE;
 
    if (Type[0] == '#') {
        for (tchar = Type + 1; *tchar; tchar++) {
            typeoff *= 10;
            typeoff += *tchar - '0';
        }
        if (dwarfseeksym(RosSymInfo, unit, typeoff, &type) == -1)
            return FALSE;
    } else if (dwarflookupnameinunit(RosSymInfo, unit, Type, &type) != 0 ||
        (type.attrs.tag != TagStructType && type.attrs.tag != TagUnionType))
        return FALSE;
 
    DwarfSym element = { }, inner = { };
    int count = 0;
 
    werrstr("type %s (want %s) type %x\n", type.attrs.name, Type, type.attrs.type);
 
    if (type.attrs.have.type) {
        if (dwarfseeksym(RosSymInfo, unit, type.attrs.type, &inner) == -1)
            return FALSE;
        type = inner;
    }
 
    werrstr("finding members %d\n", type.attrs.haskids);
    while (dwarfnextsymat(RosSymInfo, &type, &element) != -1) {
        if (element.attrs.have.name)
            werrstr("%x %s\n", element.attrs.tag, element.attrs.name);
        if (element.attrs.tag == TagMember) count++;
    }
 
    werrstr("%d members\n", count);
 
    if (!count) return FALSE;
    memset(&element, 0, sizeof(element));
    Aggregate->NumElements = count;
    Aggregate->Elements = malloc(sizeof(ROSSYM_AGGREGATE_MEMBER) * count);
    count = 0;
    werrstr("Enumerating %s\n", Type);
    while (dwarfnextsymat(RosSymInfo, &type, &element) != -1) {
        memset(&Aggregate->Elements[count], 0, sizeof(*Aggregate->Elements));
        if (element.attrs.tag == TagMember) {
            if (element.attrs.have.name) {
                Aggregate->Elements[count].Name = malloc(strlen(element.attrs.name) + 1);
                strcpy(Aggregate->Elements[count].Name, element.attrs.name);
            }
            Aggregate->Elements[count].TypeId = element.attrs.type;
            // Seek our range in loc
            DwarfBuf locbuf;
            DwarfBuf instream = { };
 
            locbuf.d = RosSymInfo;
            locbuf.addrsize = RosSymInfo->addrsize;
 
            if (element.attrs.have.datamemberloc) {
                instream = locbuf;
                instream.p = element.attrs.datamemberloc.b.data;
                instream.ep = element.attrs.datamemberloc.b.data + element.attrs.datamemberloc.b.len;
                werrstr("datamemberloc type %x %p:%x\n",
                        element.attrs.have.datamemberloc,
                        element.attrs.datamemberloc.b.data, element.attrs.datamemberloc.b.len);
            }
 
            if (dwarfgetarg(RosSymInfo, element.attrs.name, &instream, 0, NULL, &Aggregate->Elements[count].BaseOffset) == -1)
                Aggregate->Elements[count].BaseOffset = -1;
            werrstr("tag %x name %s base %x type %x\n",
                    element.attrs.tag, element.attrs.name,
                    Aggregate->Elements[count].BaseOffset,
                    Aggregate->Elements[count].TypeId);
            count++;
        }
    }
    for (count = 0; count < Aggregate->NumElements; count++) {
        memset(&type, 0, sizeof(type));
        memset(&inner, 0, sizeof(inner));
        werrstr("seeking type %x (%s) from %s\n",
                Aggregate->Elements[count].TypeId,
                Aggregate->Elements[count].Type,
                Aggregate->Elements[count].Name);
        dwarfseeksym(RosSymInfo, unit, Aggregate->Elements[count].TypeId, &type);
        while (type.attrs.have.type && type.attrs.tag != TagPointerType) {
            if (dwarfseeksym(RosSymInfo, unit, type.attrs.type, &inner) == -1)
                return FALSE;
            type = inner;
        }
        //dwarfdumpsym(RosSymInfo, &type);
        if (type.attrs.have.name) {
            Aggregate->Elements[count].Type = malloc(strlen(type.attrs.name) + 1);
            strcpy(Aggregate->Elements[count].Type, type.attrs.name);
        } else {
            char strbuf[128] = {'#'}, *bufptr = strbuf + 1;
            ulong idcopy = Aggregate->Elements[count].TypeId;
            ulong mult = 1;
            while (mult * 10 < idcopy) mult *= 10;
            while (mult > 0) {
                *bufptr++ = '0' + ((idcopy / mult) % 10);
                mult /= 10;
            }
            Aggregate->Elements[count].Type = malloc(strlen(strbuf) + 1);
            strcpy(Aggregate->Elements[count].Type, strbuf);
        }
        if (type.attrs.tag == TagPointerType)
            Aggregate->Elements[count].Size = RosSymInfo->addrsize;
        else
            Aggregate->Elements[count].Size = type.attrs.bytesize;
        if (type.attrs.have.bitsize)
            Aggregate->Elements[count].Bits = type.attrs.bitsize;
        if (type.attrs.have.bitoffset)
            Aggregate->Elements[count].FirstBit = type.attrs.bitoffset;
    }
    return TRUE;
}

RosSymCreateFromFile()

BOOLEAN RosSymCreateFromFile	(	PVOID	FileContext,
		PROSSYM_INFO *	RosSymInfo
	)

Definition at line 19 of file fromfile.c.

{
  IMAGE_DOS_HEADER DosHeader;
  IMAGE_NT_HEADERS NtHeaders;
  PIMAGE_SECTION_HEADER SectionHeaders, SectionHeader;
  unsigned SectionIndex;
  char SectionName[IMAGE_SIZEOF_SHORT_NAME];
  ROSSYM_HEADER RosSymHeader;
 
  /* Load DOS header */
  if (! RosSymReadFile(FileContext, &DosHeader, sizeof(IMAGE_DOS_HEADER)))
    {
      DPRINT1("Failed to read DOS header\n");
      return FALSE;
    }
  if (! ROSSYM_IS_VALID_DOS_HEADER(&DosHeader))
    {
      DPRINT1("Image doesn't have a valid DOS header\n");
      return FALSE;
    }
 
  /* Load NT headers */
  if (! RosSymSeekFile(FileContext, DosHeader.e_lfanew))
    {
      DPRINT1("Failed seeking to NT headers\n");
      return FALSE;
    }
  if (! RosSymReadFile(FileContext, &NtHeaders, sizeof(IMAGE_NT_HEADERS)))
    {
      DPRINT1("Failed to read NT headers\n");
      return FALSE;
    }
  if (! ROSSYM_IS_VALID_NT_HEADERS(&NtHeaders))
    {
      DPRINT1("Image doesn't have a valid PE header\n");
      return FALSE;
    }
 
  /* Load section headers */
  if (! RosSymSeekFile(FileContext, (char *) IMAGE_FIRST_SECTION(&NtHeaders) -
                                    (char *) &NtHeaders + DosHeader.e_lfanew))
    {
      DPRINT1("Failed seeking to section headers\n");
      return FALSE;
    }
  SectionHeaders = RosSymAllocMem(NtHeaders.FileHeader.NumberOfSections
                                  * sizeof(IMAGE_SECTION_HEADER));
  if (NULL == SectionHeaders)
    {
      DPRINT1("Failed to allocate memory for %u section headers\n",
              NtHeaders.FileHeader.NumberOfSections);
      return FALSE;
    }
  if (! RosSymReadFile(FileContext, SectionHeaders,
                       NtHeaders.FileHeader.NumberOfSections
                       * sizeof(IMAGE_SECTION_HEADER)))
    {
      RosSymFreeMem(SectionHeaders);
      DPRINT1("Failed to read section headers\n");
      return FALSE;
    }
 
  /* Search for the section header */
  strncpy(SectionName, ROSSYM_SECTION_NAME, IMAGE_SIZEOF_SHORT_NAME);
  SectionHeader = SectionHeaders;
  for (SectionIndex = 0; SectionIndex < NtHeaders.FileHeader.NumberOfSections; SectionIndex++)
    {
      if (0 == memcmp(SectionName, SectionHeader->Name, IMAGE_SIZEOF_SHORT_NAME))
        {
          break;
        }
      SectionHeader++;
    }
  if (NtHeaders.FileHeader.NumberOfSections <= SectionIndex)
    {
      RosSymFreeMem(SectionHeaders);
      DPRINT("No %s section found\n", ROSSYM_SECTION_NAME);
      return FALSE;
    }
 
  /* Load rossym header */
  if (! RosSymSeekFile(FileContext, SectionHeader->PointerToRawData))
    {
      RosSymFreeMem(SectionHeaders);
      DPRINT1("Failed seeking to section data\n");
      return FALSE;
    }
  RosSymFreeMem(SectionHeaders);
  if (! RosSymReadFile(FileContext, &RosSymHeader, sizeof(ROSSYM_HEADER)))
    {
      DPRINT1("Failed to read rossym header\n");
      return FALSE;
    }
  if (RosSymHeader.SymbolsOffset < sizeof(ROSSYM_HEADER)
      || RosSymHeader.StringsOffset < RosSymHeader.SymbolsOffset + RosSymHeader.SymbolsLength
      || 0 != (RosSymHeader.SymbolsLength % sizeof(ROSSYM_ENTRY)))
    {
      DPRINT1("Invalid ROSSYM_HEADER\n");
      return FALSE;
    }
 
  *RosSymInfo = RosSymAllocMem(sizeof(ROSSYM_INFO) - sizeof(ROSSYM_HEADER)
                               + RosSymHeader.StringsOffset + RosSymHeader.StringsLength + 1);
  if (NULL == *RosSymInfo)
    {
      DPRINT1("Failed to allocate memory for rossym\n");
      return FALSE;
    }
  (*RosSymInfo)->Symbols = (PROSSYM_ENTRY)((char *) *RosSymInfo + sizeof(ROSSYM_INFO)
                                           - sizeof(ROSSYM_HEADER) + RosSymHeader.SymbolsOffset);
  (*RosSymInfo)->SymbolsCount = RosSymHeader.SymbolsLength / sizeof(ROSSYM_ENTRY);
  (*RosSymInfo)->Strings = (PCHAR) *RosSymInfo + sizeof(ROSSYM_INFO) - sizeof(ROSSYM_HEADER)
                           + RosSymHeader.StringsOffset;
  (*RosSymInfo)->StringsLength = RosSymHeader.StringsLength;
  if (! RosSymReadFile(FileContext, *RosSymInfo + 1,
                       RosSymHeader.StringsOffset + RosSymHeader.StringsLength
                       - sizeof(ROSSYM_HEADER)))
    {
      DPRINT1("Failed to read rossym headers\n");
      return FALSE;
    }
  /* Make sure the last string is null terminated, we allocated an extra byte for that */
  (*RosSymInfo)->Strings[(*RosSymInfo)->StringsLength] = '\0';
 
  return TRUE;
}

Referenced by LoadSymbolsRoutine().

RosSymCreateFromMem()

BOOLEAN RosSymCreateFromMem	(	PVOID	ImageStart,
		ULONG_PTR	ImageSize,
		PROSSYM_INFO *	RosSymInfo
	)

Definition at line 19 of file frommem.c.

{
  PIMAGE_DOS_HEADER DosHeader;
  PIMAGE_NT_HEADERS NtHeaders;
  PIMAGE_SECTION_HEADER SectionHeader;
  ULONG SectionIndex;
  BOOLEAN RosSymSectionFound = FALSE;
  CHAR SectionName[IMAGE_SIZEOF_SHORT_NAME];
 
  /* Check if MZ header is valid */
  DosHeader = (PIMAGE_DOS_HEADER) ImageStart;
  if (ImageSize < sizeof(IMAGE_DOS_HEADER)
      || ! ROSSYM_IS_VALID_DOS_HEADER(DosHeader))
    {
      DPRINT1("Image doesn't have a valid DOS header\n");
      return FALSE;
    }
 
  /* Locate NT header  */
  NtHeaders = (PIMAGE_NT_HEADERS)((char *) ImageStart + DosHeader->e_lfanew);
  if (ImageSize < DosHeader->e_lfanew + sizeof(IMAGE_NT_HEADERS)
      || ! ROSSYM_IS_VALID_NT_HEADERS(NtHeaders))
    {
      DPRINT1("Image doesn't have a valid PE header\n");
      return FALSE;
    }
 
  /* Search for the section header */
  SectionHeader = IMAGE_FIRST_SECTION(NtHeaders);
  if (ImageSize < (ULONG_PTR)((char *) (SectionHeader + NtHeaders->FileHeader.NumberOfSections)
                              - (char *) ImageStart))
    {
      DPRINT1("Image doesn't have valid section headers\n");
      return FALSE;
    }
  strncpy(SectionName, ROSSYM_SECTION_NAME, IMAGE_SIZEOF_SHORT_NAME);
  for (SectionIndex = 0; SectionIndex < NtHeaders->FileHeader.NumberOfSections; SectionIndex++)
    {
      if (0 == memcmp(SectionName, SectionHeader->Name, IMAGE_SIZEOF_SHORT_NAME))
        {
          RosSymSectionFound = TRUE;
          break;
        }
      SectionHeader++;
    }
 
  if (!RosSymSectionFound)
    {
      DPRINT("No %s section found\n", ROSSYM_SECTION_NAME);
      return FALSE;
    }
 
  /* Locate the section itself */
  if (ImageSize < SectionHeader->PointerToRawData + SectionHeader->SizeOfRawData
      || SectionHeader->SizeOfRawData < sizeof(ROSSYM_HEADER))
    {
      DPRINT("Invalid %s section\n", ROSSYM_SECTION_NAME);
      return FALSE;
    }
 
  if (SectionHeader->VirtualAddress + SectionHeader->Misc.VirtualSize > ImageSize)
  {
      DPRINT("Bad %s section virtual size!\n", ROSSYM_SECTION_NAME);
      return FALSE;
  }
 
  /* Load it */
  return RosSymCreateFromRaw((char *) ImageStart + SectionHeader->VirtualAddress,
                             SectionHeader->SizeOfRawData, RosSymInfo);
}

Referenced by KdbSymProcessSymbols().

RosSymCreateFromRaw()

BOOLEAN RosSymCreateFromRaw	(	PVOID	RawData,
		ULONG_PTR	DataSize,
		PROSSYM_INFO *	RosSymInfo
	)

Definition at line 18 of file fromraw.c.

{
  PROSSYM_HEADER RosSymHeader;
 
  RosSymHeader = (PROSSYM_HEADER) RawData;
  if (RosSymHeader->SymbolsOffset < sizeof(ROSSYM_HEADER)
      || RosSymHeader->StringsOffset < RosSymHeader->SymbolsOffset + RosSymHeader->SymbolsLength
      || DataSize < RosSymHeader->StringsOffset + RosSymHeader->StringsLength
      || 0 != (RosSymHeader->SymbolsLength % sizeof(ROSSYM_ENTRY)))
    {
      DPRINT1("Invalid ROSSYM_HEADER\n");
      return FALSE;
    }
 
  /* Copy */
  *RosSymInfo = RosSymAllocMem(sizeof(ROSSYM_INFO) + RosSymHeader->SymbolsLength
                               + RosSymHeader->StringsLength + 1);
  if (NULL == *RosSymInfo)
    {
      DPRINT1("Failed to allocate memory for rossym\n");
      return FALSE;
    }
  (*RosSymInfo)->Symbols = (PROSSYM_ENTRY)((char *) *RosSymInfo + sizeof(ROSSYM_INFO));
  (*RosSymInfo)->SymbolsCount = RosSymHeader->SymbolsLength / sizeof(ROSSYM_ENTRY);
  (*RosSymInfo)->Strings = (PCHAR) *RosSymInfo + sizeof(ROSSYM_INFO) + RosSymHeader->SymbolsLength;
  (*RosSymInfo)->StringsLength = RosSymHeader->StringsLength;
  memcpy((*RosSymInfo)->Symbols, (char *) RosSymHeader + RosSymHeader->SymbolsOffset,
         RosSymHeader->SymbolsLength);
  memcpy((*RosSymInfo)->Strings, (char *) RosSymHeader + RosSymHeader->StringsOffset,
         RosSymHeader->StringsLength);
  /* Make sure the last string is null terminated, we allocated an extra byte for that */
  (*RosSymInfo)->Strings[(*RosSymInfo)->StringsLength] = '\0';
 
  return TRUE;
}

Referenced by RosSymCreateFromMem().

RosSymDelete()

VOID RosSymDelete

(

PROSSYM_INFO

RosSymInfo

)

Definition at line 15 of file delete.c.

{
  RosSymFreeMem(RosSymInfo);
}

Referenced by KdbSymProcessSymbols().

RosSymFreeAggregate()

VOID RosSymFreeAggregate

(

PROSSYM_AGGREGATE

Aggregate

)

Definition at line 126 of file find.c.

{
    int i;
    for (i = 0; i < Aggregate->NumElements; i++) {
        free(Aggregate->Elements[i].Name);
        free(Aggregate->Elements[i].Type);
    }
    free(Aggregate->Elements);
}

RosSymFreeInfo()

VOID RosSymFreeInfo

(

PROSSYM_LINEINFO

RosSymLineInfo

)

Definition at line 398 of file dwarfpc.c.

{
    int i;
    free(LineInfo->FileName);
    LineInfo->FileName = NULL;
    free(LineInfo->FunctionName);
    LineInfo->FunctionName = NULL;
    for (i = 0; i < sizeof(LineInfo->Parameters)/sizeof(LineInfo->Parameters[0]); i++)
        free(LineInfo->Parameters[i].ValueName);
}

RosSymGetAddressInformation()

BOOLEAN RosSymGetAddressInformation	(	PROSSYM_INFO	RosSymInfo,
		ULONG_PTR	RelativeAddress,
		ULONG *	LineNumber,
		char *	FileName,
		char *	FunctionName
	)

Definition at line 94 of file find.c.

{
  PROSSYM_ENTRY RosSymEntry;
 
  DPRINT("RelativeAddress = 0x%08x\n", RelativeAddress);
 
  if (RosSymInfo->Symbols == NULL || RosSymInfo->SymbolsCount == 0 ||
      RosSymInfo->Strings == NULL || RosSymInfo->StringsLength == 0)
    {
      DPRINT1("Uninitialized RosSymInfo\n");
      return FALSE;
    }
 
  ASSERT(LineNumber || FileName || FunctionName);
 
  /* find symbol entry for function */
  RosSymEntry = FindEntry(RosSymInfo, RelativeAddress);
 
  if (NULL == RosSymEntry)
    {
      DPRINT("None of the requested information was found!\n");
      return FALSE;
    }
 
  if (LineNumber != NULL)
    {
      *LineNumber = RosSymEntry->SourceLine;
    }
  if (FileName != NULL)
    {
      PCSTR Name = "";
      if (RosSymEntry->FileOffset != 0)
        {
          Name = (PCHAR) RosSymInfo->Strings + RosSymEntry->FileOffset;
        }
      strcpy(FileName, Name);
    }
  if (FunctionName != NULL)
    {
      PCSTR Name = "";
      if (RosSymEntry->FunctionOffset != 0)
        {
          Name = (PCHAR) RosSymInfo->Strings + RosSymEntry->FunctionOffset;
        }
      strcpy(FunctionName, Name);
    }
 
  return TRUE;
}

Referenced by KdbSymPrintAddress().

RosSymGetRawData()

VOID RosSymGetRawData	(	PROSSYM_INFO	RosSymInfo,
		PVOID	RawData
	)

Definition at line 23 of file getraw.c.

{
  PROSSYM_HEADER RosSymHeader;
 
  RosSymHeader = (PROSSYM_HEADER) RawData;
  RosSymHeader->SymbolsOffset = sizeof(ROSSYM_HEADER);
  RosSymHeader->SymbolsLength = RosSymInfo->SymbolsCount * sizeof(ROSSYM_ENTRY);
  RosSymHeader->StringsOffset = RosSymHeader->SymbolsOffset + RosSymHeader->SymbolsLength;
  RosSymHeader->StringsLength = RosSymInfo->StringsLength;
 
  memcpy((char *) RawData + RosSymHeader->SymbolsOffset, RosSymInfo->Symbols,
         RosSymHeader->SymbolsLength);
  memcpy((char *) RawData + RosSymHeader->StringsOffset, RosSymInfo->Strings,
         RosSymHeader->StringsLength);
}

RosSymGetRawDataLength()

ULONG RosSymGetRawDataLength

(

PROSSYM_INFO

RosSymInfo

)

Definition at line 15 of file getraw.c.

{
  return sizeof(ROSSYM_HEADER)
         + RosSymInfo->SymbolsCount * sizeof(ROSSYM_ENTRY)
         + RosSymInfo->StringsLength;
}

RosSymInit()

VOID RosSymInit

(

PROSSYM_CALLBACKS

Callbacks

)

Definition at line 17 of file init.c.

{
  RosSymCallbacks = *Callbacks;
}

Referenced by RosSymInitKernelMode(), and RosSymInitUserMode().

RosSymInitKernelMode()

VOID RosSymInitKernelMode

(

VOID

)

Definition at line 32 of file initkm.c.

{
  static ROSSYM_CALLBACKS KmCallbacks =
    {
      RosSymAllocMemKM,
      RosSymFreeMemKM,
      RosSymZwReadFile,
      RosSymZwSeekFile
    };
 
  RosSymInit(&KmCallbacks);
}

Referenced by KdbSymInit().

RosSymInitUserMode()

VOID RosSymInitUserMode

(

VOID

)

Definition at line 29 of file initum.c.

{
  static ROSSYM_CALLBACKS KmCallbacks =
    {
      RosSymAllocMemUM,
      RosSymFreeMemUM,
      RosSymZwReadFile,
      RosSymZwSeekFile
    };
 
  RosSymInit(&KmCallbacks);
}