mirror of
https://github.com/Ed94/raddebugger.git
synced 2026-08-05 05:18:40 +00:00
raddbgi_ -> rdi_
This commit is contained in:
Ryan Fleury
@@ -4,24 +4,24 @@
|
||||
////////////////////////////////
|
||||
// Functions
|
||||
|
||||
RADDBGI_PROC RADDBGI_U64
|
||||
raddbgi_hash(RADDBGI_U8 *ptr, RADDBGI_U64 size){
|
||||
RADDBGI_U64 result = 5381;
|
||||
RADDBGI_U8 *opl = ptr + size;
|
||||
RDI_PROC RDI_U64
|
||||
rdi_hash(RDI_U8 *ptr, RDI_U64 size){
|
||||
RDI_U64 result = 5381;
|
||||
RDI_U8 *opl = ptr + size;
|
||||
for (; ptr < opl; ptr += 1){
|
||||
result = ((result << 5) + result) + *ptr;
|
||||
}
|
||||
return(result);
|
||||
}
|
||||
|
||||
RADDBGI_PROC RADDBGI_U32
|
||||
raddbgi_size_from_basic_type_kind(RADDBGI_TypeKind kind){
|
||||
RADDBGI_U32 result = 0;
|
||||
RDI_PROC RDI_U32
|
||||
rdi_size_from_basic_type_kind(RDI_TypeKind kind){
|
||||
RDI_U32 result = 0;
|
||||
switch (kind){
|
||||
#define X(N,C)
|
||||
#define XZ(N,C,Z) case C: result = Z; break;
|
||||
#define Y(A,N)
|
||||
RADDBGI_TypeKindXList(X,XZ,Y)
|
||||
RDI_TypeKindXList(X,XZ,Y)
|
||||
#undef X
|
||||
#undef XZ
|
||||
#undef Y
|
||||
@@ -29,12 +29,12 @@ raddbgi_size_from_basic_type_kind(RADDBGI_TypeKind kind){
|
||||
return(result);
|
||||
}
|
||||
|
||||
RADDBGI_PROC RADDBGI_U32
|
||||
raddbgi_addr_size_from_arch(RADDBGI_Arch arch){
|
||||
RADDBGI_U32 result = 0;
|
||||
RDI_PROC RDI_U32
|
||||
rdi_addr_size_from_arch(RDI_Arch arch){
|
||||
RDI_U32 result = 0;
|
||||
switch (arch){
|
||||
#define X(N,C,Z) case C: result = Z; break;
|
||||
RADDBGI_ArchXList(X)
|
||||
RDI_ArchXList(X)
|
||||
#undef X
|
||||
}
|
||||
return(result);
|
||||
@@ -42,14 +42,14 @@ raddbgi_addr_size_from_arch(RADDBGI_Arch arch){
|
||||
|
||||
//- eval helpers
|
||||
|
||||
RADDBGI_PROC RADDBGI_EvalConversionKind
|
||||
raddbgi_eval_conversion_rule(RADDBGI_EvalTypeGroup in, RADDBGI_EvalTypeGroup out){
|
||||
RADDBGI_EvalConversionKind result = 0;
|
||||
RDI_PROC RDI_EvalConversionKind
|
||||
rdi_eval_conversion_rule(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out){
|
||||
RDI_EvalConversionKind result = 0;
|
||||
switch (in + (out << 8)){
|
||||
#define Y(i,o) case ((RADDBGI_EvalTypeGroup_##i) + ((RADDBGI_EvalTypeGroup_##o) << 8)):
|
||||
#define Y(i,o) case ((RDI_EvalTypeGroup_##i) + ((RDI_EvalTypeGroup_##o) << 8)):
|
||||
#define Xb(c)
|
||||
#define Xe(c) result = RADDBGI_EvalConversionKind_##c; break;
|
||||
RADDBGI_EvalConversionKindFromTypeGroupPairMap(Y,Xb,Xe)
|
||||
#define Xe(c) result = RDI_EvalConversionKind_##c; break;
|
||||
RDI_EvalConversionKindFromTypeGroupPairMap(Y,Xb,Xe)
|
||||
#undef Xe
|
||||
#undef Xb
|
||||
#undef Y
|
||||
@@ -57,38 +57,38 @@ raddbgi_eval_conversion_rule(RADDBGI_EvalTypeGroup in, RADDBGI_EvalTypeGroup out
|
||||
return(result);
|
||||
}
|
||||
|
||||
RADDBGI_PROC RADDBGI_U8*
|
||||
raddbgi_eval_conversion_message(RADDBGI_EvalConversionKind conversion_kind, RADDBGI_U64 *lenout){
|
||||
RADDBGI_U8 *result = 0;
|
||||
RDI_PROC RDI_U8*
|
||||
rdi_eval_conversion_message(RDI_EvalConversionKind conversion_kind, RDI_U64 *lenout){
|
||||
RDI_U8 *result = 0;
|
||||
switch (conversion_kind){
|
||||
#define X(N,msg) \
|
||||
case RADDBGI_EvalConversionKind_##N: result = (RADDBGI_U8*)msg; *lenout = sizeof(msg) - 1; break;
|
||||
RADDBGI_EvalConversionKindXList(X)
|
||||
case RDI_EvalConversionKind_##N: result = (RDI_U8*)msg; *lenout = sizeof(msg) - 1; break;
|
||||
RDI_EvalConversionKindXList(X)
|
||||
#undef X
|
||||
}
|
||||
return(result);
|
||||
}
|
||||
|
||||
RADDBGI_PROC RADDBGI_S32
|
||||
raddbgi_eval_opcode_type_compatible(RADDBGI_EvalOp op, RADDBGI_EvalTypeGroup group){
|
||||
RADDBGI_S32 result = 0;
|
||||
RDI_PROC RDI_S32
|
||||
rdi_eval_opcode_type_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group){
|
||||
RDI_S32 result = 0;
|
||||
switch (op){
|
||||
case RADDBGI_EvalOp_Neg: case RADDBGI_EvalOp_Add: case RADDBGI_EvalOp_Sub:
|
||||
case RADDBGI_EvalOp_Mul: case RADDBGI_EvalOp_Div:
|
||||
case RADDBGI_EvalOp_EqEq:case RADDBGI_EvalOp_NtEq:
|
||||
case RADDBGI_EvalOp_LsEq:case RADDBGI_EvalOp_GrEq:
|
||||
case RADDBGI_EvalOp_Less:case RADDBGI_EvalOp_Grtr:
|
||||
case RDI_EvalOp_Neg: case RDI_EvalOp_Add: case RDI_EvalOp_Sub:
|
||||
case RDI_EvalOp_Mul: case RDI_EvalOp_Div:
|
||||
case RDI_EvalOp_EqEq:case RDI_EvalOp_NtEq:
|
||||
case RDI_EvalOp_LsEq:case RDI_EvalOp_GrEq:
|
||||
case RDI_EvalOp_Less:case RDI_EvalOp_Grtr:
|
||||
{
|
||||
if (group != RADDBGI_EvalTypeGroup_Other){
|
||||
if (group != RDI_EvalTypeGroup_Other){
|
||||
result = 1;
|
||||
}
|
||||
}break;
|
||||
case RADDBGI_EvalOp_Mod:case RADDBGI_EvalOp_LShift:case RADDBGI_EvalOp_RShift:
|
||||
case RADDBGI_EvalOp_BitNot:case RADDBGI_EvalOp_BitAnd:case RADDBGI_EvalOp_BitXor:
|
||||
case RADDBGI_EvalOp_BitOr:case RADDBGI_EvalOp_LogNot:case RADDBGI_EvalOp_LogAnd:
|
||||
case RADDBGI_EvalOp_LogOr:
|
||||
case RDI_EvalOp_Mod:case RDI_EvalOp_LShift:case RDI_EvalOp_RShift:
|
||||
case RDI_EvalOp_BitNot:case RDI_EvalOp_BitAnd:case RDI_EvalOp_BitXor:
|
||||
case RDI_EvalOp_BitOr:case RDI_EvalOp_LogNot:case RDI_EvalOp_LogAnd:
|
||||
case RDI_EvalOp_LogOr:
|
||||
{
|
||||
if (group == RADDBGI_EvalTypeGroup_S || group == RADDBGI_EvalTypeGroup_U){
|
||||
if (group == RDI_EvalTypeGroup_S || group == RDI_EvalTypeGroup_U){
|
||||
result = 1;
|
||||
}
|
||||
}break;
|
||||
|
||||
@@ -1,60 +1,66 @@
|
||||
// Copyright (c) 2024 Epic Games Tools
|
||||
// Licensed under the MIT license (https://opensource.org/license/mit/)
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
// RAD Debug Info, (R)AD(D)BG(I) Format Library
|
||||
//
|
||||
// Defines standard RADDBGI debug information format types and
|
||||
// functions.
|
||||
|
||||
#ifndef RADDBGI_FORMAT_H
|
||||
#define RADDBGI_FORMAT_H
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
// Overridable procedure decoration
|
||||
|
||||
#if !defined(RADDBGI_PROC)
|
||||
# define RADDBGI_PROC static
|
||||
#if !defined(RDI_PROC)
|
||||
# define RDI_PROC static
|
||||
#endif
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
// Overridable integer types
|
||||
|
||||
#if !defined(RADDBGI_U8)
|
||||
# define RADDBGI_U8 RADDBGI_U8
|
||||
# define RADDBGI_U16 RADDBGI_U16
|
||||
# define RADDBGI_U32 RADDBGI_U32
|
||||
# define RADDBGI_U64 RADDBGI_U64
|
||||
# define RADDBGI_S8 RADDBGI_S8
|
||||
# define RADDBGI_S16 RADDBGI_S16
|
||||
# define RADDBGI_S32 RADDBGI_S32
|
||||
# define RADDBGI_S64 RADDBGI_S64
|
||||
#if !defined(RDI_U8)
|
||||
# define RDI_U8 RDI_U8
|
||||
# define RDI_U16 RDI_U16
|
||||
# define RDI_U32 RDI_U32
|
||||
# define RDI_U64 RDI_U64
|
||||
# define RDI_S8 RDI_S8
|
||||
# define RDI_S16 RDI_S16
|
||||
# define RDI_S32 RDI_S32
|
||||
# define RDI_S64 RDI_S64
|
||||
|
||||
#include <stdint.h>
|
||||
typedef uint8_t RADDBGI_U8;
|
||||
typedef uint16_t RADDBGI_U16;
|
||||
typedef uint32_t RADDBGI_U32;
|
||||
typedef uint64_t RADDBGI_U64;
|
||||
typedef int8_t RADDBGI_S8;
|
||||
typedef int16_t RADDBGI_S16;
|
||||
typedef int32_t RADDBGI_S32;
|
||||
typedef int64_t RADDBGI_S64;
|
||||
typedef uint8_t RDI_U8;
|
||||
typedef uint16_t RDI_U16;
|
||||
typedef uint32_t RDI_U32;
|
||||
typedef uint64_t RDI_U64;
|
||||
typedef int8_t RDI_S8;
|
||||
typedef int16_t RDI_S16;
|
||||
typedef int32_t RDI_S32;
|
||||
typedef int64_t RDI_S64;
|
||||
#endif
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
// Architecture Constants
|
||||
|
||||
#define RADDBGI_ArchXList(X)\
|
||||
#define RDI_ArchXList(X)\
|
||||
X(NULL, 0, 0)\
|
||||
X(X86, 1, 4)\
|
||||
X(X64, 2, 8)
|
||||
|
||||
typedef RADDBGI_U32 RADDBGI_Arch;
|
||||
typedef enum RADDBGI_ArchEnum{
|
||||
#define X(N,C,Z) RADDBGI_Arch_##N = C,
|
||||
RADDBGI_ArchXList(X)
|
||||
typedef RDI_U32 RDI_Arch;
|
||||
typedef enum RDI_ArchEnum{
|
||||
#define X(N,C,Z) RDI_Arch_##N = C,
|
||||
RDI_ArchXList(X)
|
||||
#undef X
|
||||
} RADDBGI_ArchEnum;
|
||||
} RDI_ArchEnum;
|
||||
|
||||
|
||||
typedef RADDBGI_U8 RADDBGI_RegisterCode;
|
||||
typedef RDI_U8 RDI_RegisterCode;
|
||||
|
||||
// x86 registers
|
||||
#define RADDBGI_RegisterCode_X86_XList(X) \
|
||||
#define RDI_RegisterCode_X86_XList(X) \
|
||||
X(nil, 0) \
|
||||
X(eax, 1) \
|
||||
X(ecx, 2) \
|
||||
@@ -118,14 +124,14 @@ X(ymm6, 59) \
|
||||
X(ymm7, 60) \
|
||||
X(COUNT, 61)
|
||||
|
||||
typedef enum RADDBGI_RegisterCode_X86_Enum{
|
||||
#define X(N,C) RADDBGI_RegisterCode_X86_##N = C,
|
||||
RADDBGI_RegisterCode_X86_XList(X)
|
||||
typedef enum RDI_RegisterCode_X86_Enum{
|
||||
#define X(N,C) RDI_RegisterCode_X86_##N = C,
|
||||
RDI_RegisterCode_X86_XList(X)
|
||||
#undef X
|
||||
} RADDBGI_RegisterCode_X86_Enum;
|
||||
} RDI_RegisterCode_X86_Enum;
|
||||
|
||||
// x64 registers
|
||||
#define RADDBGI_RegisterCode_X64_XList(X) \
|
||||
#define RDI_RegisterCode_X64_XList(X) \
|
||||
X(nil, 0) \
|
||||
X(rax, 1) \
|
||||
X(rcx, 2) \
|
||||
@@ -205,48 +211,48 @@ X(fdp, 75) \
|
||||
X(mxcsr_mask, 76) \
|
||||
X(COUNT, 77)
|
||||
|
||||
typedef enum RADDBGI_RegisterCode_X64_Enum{
|
||||
#define X(N,C) RADDBGI_RegisterCode_X64_##N = C,
|
||||
RADDBGI_RegisterCode_X64_XList(X)
|
||||
typedef enum RDI_RegisterCode_X64_Enum{
|
||||
#define X(N,C) RDI_RegisterCode_X64_##N = C,
|
||||
RDI_RegisterCode_X64_XList(X)
|
||||
#undef X
|
||||
} RADDBGI_RegisterCode_X64_Enum;
|
||||
} RDI_RegisterCode_X64_Enum;
|
||||
|
||||
|
||||
////////////////////////////////////////////////////////////////
|
||||
// Format types
|
||||
|
||||
// "raddbg\0\0"
|
||||
#define RADDBGI_MAGIC_CONSTANT 0x0000676264646172
|
||||
#define RADDBGI_ENCODING_VERSION 1
|
||||
#define RDI_MAGIC_CONSTANT 0x0000676264646172
|
||||
#define RDI_ENCODING_VERSION 1
|
||||
|
||||
#define RADDBGI_LanguageXList(X) \
|
||||
#define RDI_LanguageXList(X) \
|
||||
X(NULL, 0) \
|
||||
X(C, 1) \
|
||||
X(CPlusPlus, 2)
|
||||
|
||||
typedef RADDBGI_U32 RADDBGI_Language;
|
||||
typedef enum RADDBGI_LanguageEnum{
|
||||
#define X(N,C) RADDBGI_Language_##N = C,
|
||||
RADDBGI_LanguageXList(X)
|
||||
typedef RDI_U32 RDI_Language;
|
||||
typedef enum RDI_LanguageEnum{
|
||||
#define X(N,C) RDI_Language_##N = C,
|
||||
RDI_LanguageXList(X)
|
||||
#undef X
|
||||
} RADDBGI_LanguageEnum;
|
||||
} RDI_LanguageEnum;
|
||||
|
||||
typedef struct RADDBGI_Header{
|
||||
typedef struct RDI_Header{
|
||||
// identification
|
||||
RADDBGI_U64 magic;
|
||||
RADDBGI_U32 encoding_version;
|
||||
RDI_U64 magic;
|
||||
RDI_U32 encoding_version;
|
||||
|
||||
// data sections
|
||||
RADDBGI_U32 data_section_off;
|
||||
RADDBGI_U32 data_section_count;
|
||||
} RADDBGI_Header;
|
||||
RDI_U32 data_section_off;
|
||||
RDI_U32 data_section_count;
|
||||
} RDI_Header;
|
||||
|
||||
|
||||
//- data sections
|
||||
|
||||
#define RADDBGI_DataSectionTag_SECONDARY 0x80000000
|
||||
#define RDI_DataSectionTag_SECONDARY 0x80000000
|
||||
|
||||
#define RADDBGI_DataSectionTagXList(X,Y) \
|
||||
#define RDI_DataSectionTagXList(X,Y) \
|
||||
X(NULL, 0x0000)\
|
||||
X(TopLevelInfo, 0x0001)\
|
||||
X(StringData, 0x0002)\
|
||||
@@ -273,131 +279,131 @@ X(LocationBlocks, 0x0016)\
|
||||
X(LocationData, 0x0017)\
|
||||
X(NameMaps, 0x0018)\
|
||||
Y(PRIMARY_COUNT)\
|
||||
X(SKIP, RADDBGI_DataSectionTag_SECONDARY|0x0000)\
|
||||
X(LineInfoVoffs, RADDBGI_DataSectionTag_SECONDARY|0x0001)\
|
||||
X(LineInfoData, RADDBGI_DataSectionTag_SECONDARY|0x0002)\
|
||||
X(LineInfoColumns, RADDBGI_DataSectionTag_SECONDARY|0x0003)\
|
||||
X(LineMapNumbers, RADDBGI_DataSectionTag_SECONDARY|0x0004)\
|
||||
X(LineMapRanges, RADDBGI_DataSectionTag_SECONDARY|0x0005)\
|
||||
X(LineMapVoffs, RADDBGI_DataSectionTag_SECONDARY|0x0006)\
|
||||
X(NameMapBuckets, RADDBGI_DataSectionTag_SECONDARY|0x0007)\
|
||||
X(NameMapNodes, RADDBGI_DataSectionTag_SECONDARY|0x0008)
|
||||
X(SKIP, RDI_DataSectionTag_SECONDARY|0x0000)\
|
||||
X(LineInfoVoffs, RDI_DataSectionTag_SECONDARY|0x0001)\
|
||||
X(LineInfoData, RDI_DataSectionTag_SECONDARY|0x0002)\
|
||||
X(LineInfoColumns, RDI_DataSectionTag_SECONDARY|0x0003)\
|
||||
X(LineMapNumbers, RDI_DataSectionTag_SECONDARY|0x0004)\
|
||||
X(LineMapRanges, RDI_DataSectionTag_SECONDARY|0x0005)\
|
||||
X(LineMapVoffs, RDI_DataSectionTag_SECONDARY|0x0006)\
|
||||
X(NameMapBuckets, RDI_DataSectionTag_SECONDARY|0x0007)\
|
||||
X(NameMapNodes, RDI_DataSectionTag_SECONDARY|0x0008)
|
||||
|
||||
typedef RADDBGI_U32 RADDBGI_DataSectionTag;
|
||||
typedef enum RADDBGI_DataSectionTagEnum{
|
||||
#define X(N,C) RADDBGI_DataSectionTag_##N = C,
|
||||
#define Y(N) RADDBGI_DataSectionTag_##N,
|
||||
RADDBGI_DataSectionTagXList(X,Y)
|
||||
typedef RDI_U32 RDI_DataSectionTag;
|
||||
typedef enum RDI_DataSectionTagEnum{
|
||||
#define X(N,C) RDI_DataSectionTag_##N = C,
|
||||
#define Y(N) RDI_DataSectionTag_##N,
|
||||
RDI_DataSectionTagXList(X,Y)
|
||||
#undef X
|
||||
#undef Y
|
||||
} RADDBGI_DataSectionTagEnum;
|
||||
} RDI_DataSectionTagEnum;
|
||||
|
||||
|
||||
#define RADDBGI_DataSectionEncodingXList(X) \
|
||||
#define RDI_DataSectionEncodingXList(X) \
|
||||
X(Unpacked, 0)
|
||||
|
||||
typedef RADDBGI_U32 RADDBGI_DataSectionEncoding;
|
||||
typedef enum RADDBGI_DataSectionEncodingEnum{
|
||||
#define X(N,C) RADDBGI_DataSectionEncoding_##N = C,
|
||||
RADDBGI_DataSectionEncodingXList(X)
|
||||
typedef RDI_U32 RDI_DataSectionEncoding;
|
||||
typedef enum RDI_DataSectionEncodingEnum{
|
||||
#define X(N,C) RDI_DataSectionEncoding_##N = C,
|
||||
RDI_DataSectionEncodingXList(X)
|
||||
#undef X
|
||||
} RADDBGI_DataSectionEncodingEnum;
|
||||
} RDI_DataSectionEncodingEnum;
|
||||
|
||||
typedef struct RADDBGI_DataSection{
|
||||
RADDBGI_DataSectionTag tag;
|
||||
RADDBGI_DataSectionEncoding encoding;
|
||||
RADDBGI_U64 off;
|
||||
RADDBGI_U64 encoded_size;
|
||||
RADDBGI_U64 unpacked_size;
|
||||
} RADDBGI_DataSection;
|
||||
typedef struct RDI_DataSection{
|
||||
RDI_DataSectionTag tag;
|
||||
RDI_DataSectionEncoding encoding;
|
||||
RDI_U64 off;
|
||||
RDI_U64 encoded_size;
|
||||
RDI_U64 unpacked_size;
|
||||
} RDI_DataSection;
|
||||
|
||||
|
||||
//- common types
|
||||
typedef struct RADDBGI_VMapEntry{
|
||||
RADDBGI_U64 voff;
|
||||
RADDBGI_U64 idx;
|
||||
} RADDBGI_VMapEntry;
|
||||
typedef struct RDI_VMapEntry{
|
||||
RDI_U64 voff;
|
||||
RDI_U64 idx;
|
||||
} RDI_VMapEntry;
|
||||
|
||||
//- top level info
|
||||
typedef struct RADDBGI_TopLevelInfo{
|
||||
RADDBGI_Arch architecture;
|
||||
RADDBGI_U32 exe_name_string_idx;
|
||||
RADDBGI_U64 exe_hash;
|
||||
RADDBGI_U64 voff_max;
|
||||
} RADDBGI_TopLevelInfo;
|
||||
typedef struct RDI_TopLevelInfo{
|
||||
RDI_Arch architecture;
|
||||
RDI_U32 exe_name_string_idx;
|
||||
RDI_U64 exe_hash;
|
||||
RDI_U64 voff_max;
|
||||
} RDI_TopLevelInfo;
|
||||
|
||||
//- binary sections
|
||||
typedef RADDBGI_U32 RADDBGI_BinarySectionFlags;
|
||||
typedef enum RADDBGI_BinarySectionFlagsEnum{
|
||||
RADDBGI_BinarySectionFlag_Read = (1 << 0),
|
||||
RADDBGI_BinarySectionFlag_Write = (1 << 1),
|
||||
RADDBGI_BinarySectionFlag_Execute = (1 << 2)
|
||||
} RADDBGI_BinarySectionFlagsEnum;
|
||||
typedef RDI_U32 RDI_BinarySectionFlags;
|
||||
typedef enum RDI_BinarySectionFlagsEnum{
|
||||
RDI_BinarySectionFlag_Read = (1 << 0),
|
||||
RDI_BinarySectionFlag_Write = (1 << 1),
|
||||
RDI_BinarySectionFlag_Execute = (1 << 2)
|
||||
} RDI_BinarySectionFlagsEnum;
|
||||
|
||||
typedef struct RADDBGI_BinarySection{
|
||||
RADDBGI_U32 name_string_idx;
|
||||
RADDBGI_BinarySectionFlags flags;
|
||||
RADDBGI_U64 voff_first;
|
||||
RADDBGI_U64 voff_opl;
|
||||
RADDBGI_U64 foff_first;
|
||||
RADDBGI_U64 foff_opl;
|
||||
} RADDBGI_BinarySection;
|
||||
typedef struct RDI_BinarySection{
|
||||
RDI_U32 name_string_idx;
|
||||
RDI_BinarySectionFlags flags;
|
||||
RDI_U64 voff_first;
|
||||
RDI_U64 voff_opl;
|
||||
RDI_U64 foff_first;
|
||||
RDI_U64 foff_opl;
|
||||
} RDI_BinarySection;
|
||||
|
||||
//- file & file system info
|
||||
typedef struct RADDBGI_FilePathNode{
|
||||
RADDBGI_U32 name_string_idx;
|
||||
RADDBGI_U32 parent_path_node;
|
||||
RADDBGI_U32 first_child;
|
||||
RADDBGI_U32 next_sibling;
|
||||
RADDBGI_U32 source_file_idx;
|
||||
} RADDBGI_FilePathNode;
|
||||
typedef struct RDI_FilePathNode{
|
||||
RDI_U32 name_string_idx;
|
||||
RDI_U32 parent_path_node;
|
||||
RDI_U32 first_child;
|
||||
RDI_U32 next_sibling;
|
||||
RDI_U32 source_file_idx;
|
||||
} RDI_FilePathNode;
|
||||
|
||||
typedef struct RADDBGI_SourceFile{
|
||||
RADDBGI_U32 file_path_node_idx;
|
||||
typedef struct RDI_SourceFile{
|
||||
RDI_U32 file_path_node_idx;
|
||||
|
||||
RADDBGI_U32 normal_full_path_string_idx;
|
||||
RDI_U32 normal_full_path_string_idx;
|
||||
|
||||
// usage of line map to go from a line number to an array of voffs
|
||||
// (line_map_nums * line_number) -> (nil | index)
|
||||
// (line_map_data * index) -> (range)
|
||||
// (line_map_voff_data * range) -> (array(voff))
|
||||
|
||||
RADDBGI_U32 line_map_count;
|
||||
RADDBGI_U32 line_map_nums_data_idx; // U32[line_map_count] (sorted - not closed ranges)
|
||||
RADDBGI_U32 line_map_range_data_idx; // U32[line_map_count + 1] (pairs form ranges)
|
||||
RADDBGI_U32 line_map_voff_data_idx; // U64[...] (idx by line_map_range_data)
|
||||
} RADDBGI_SourceFile;
|
||||
RDI_U32 line_map_count;
|
||||
RDI_U32 line_map_nums_data_idx; // U32[line_map_count] (sorted - not closed ranges)
|
||||
RDI_U32 line_map_range_data_idx; // U32[line_map_count + 1] (pairs form ranges)
|
||||
RDI_U32 line_map_voff_data_idx; // U64[...] (idx by line_map_range_data)
|
||||
} RDI_SourceFile;
|
||||
|
||||
|
||||
//- units & line info
|
||||
typedef struct RADDBGI_Unit{
|
||||
RADDBGI_U32 unit_name_string_idx;
|
||||
RADDBGI_U32 compiler_name_string_idx;
|
||||
RADDBGI_U32 source_file_path_node;
|
||||
RADDBGI_U32 object_file_path_node;
|
||||
RADDBGI_U32 archive_file_path_node;
|
||||
RADDBGI_U32 build_path_node;
|
||||
RADDBGI_Language language;
|
||||
typedef struct RDI_Unit{
|
||||
RDI_U32 unit_name_string_idx;
|
||||
RDI_U32 compiler_name_string_idx;
|
||||
RDI_U32 source_file_path_node;
|
||||
RDI_U32 object_file_path_node;
|
||||
RDI_U32 archive_file_path_node;
|
||||
RDI_U32 build_path_node;
|
||||
RDI_Language language;
|
||||
|
||||
// usage of line info to go from voff to file & line number:
|
||||
// (line_info_voffs * voff) -> (nil + index)
|
||||
// (line_info_data * index) -> (RADDBGI_Line = (file_idx * line_number))
|
||||
// (line_info_data * index) -> (RDI_Line = (file_idx * line_number))
|
||||
|
||||
RADDBGI_U32 line_info_voffs_data_idx; // U64[line_info_count + 1] (sorted ranges)
|
||||
RADDBGI_U32 line_info_data_idx; // RADDBGI_Line[line_info_count]
|
||||
RADDBGI_U32 line_info_col_data_idx; // RADDBGI_Col[line_info_count]
|
||||
RADDBGI_U32 line_info_count;
|
||||
} RADDBGI_Unit;
|
||||
RDI_U32 line_info_voffs_data_idx; // U64[line_info_count + 1] (sorted ranges)
|
||||
RDI_U32 line_info_data_idx; // RDI_Line[line_info_count]
|
||||
RDI_U32 line_info_col_data_idx; // RDI_Col[line_info_count]
|
||||
RDI_U32 line_info_count;
|
||||
} RDI_Unit;
|
||||
|
||||
typedef struct RADDBGI_Line{
|
||||
RADDBGI_U32 file_idx;
|
||||
RADDBGI_U32 line_num;
|
||||
} RADDBGI_Line;
|
||||
typedef struct RDI_Line{
|
||||
RDI_U32 file_idx;
|
||||
RDI_U32 line_num;
|
||||
} RDI_Line;
|
||||
|
||||
typedef struct RADDBGI_Column{
|
||||
RADDBGI_U16 col_first;
|
||||
RADDBGI_U16 col_opl;
|
||||
} RADDBGI_Column;
|
||||
typedef struct RDI_Column{
|
||||
RDI_U16 col_first;
|
||||
RDI_U16 col_opl;
|
||||
} RDI_Column;
|
||||
|
||||
|
||||
//- type info
|
||||
@@ -405,7 +411,7 @@ typedef struct RADDBGI_Column{
|
||||
// X(name,code) - defines a primary code
|
||||
// XZ(name,code size) - defines a primary code & associates a size
|
||||
// Y(alias_name,name) - defines an alias for bookends
|
||||
#define RADDBGI_TypeKindXList(X,XZ,Y)\
|
||||
#define RDI_TypeKindXList(X,XZ,Y)\
|
||||
X(NULL, 0x0000) \
|
||||
\
|
||||
XZ(Void, 0x0001, 0) Y(FirstBuiltIn, Void) \
|
||||
@@ -466,23 +472,23 @@ Y(LastUserDefined, IncompleteEnum) \
|
||||
X(Bitfield, 0xF000) \
|
||||
X(Variadic, 0xF001)
|
||||
|
||||
typedef RADDBGI_U16 RADDBGI_TypeKind;
|
||||
typedef enum RADDBGI_TypeKindEnum{
|
||||
typedef RDI_U16 RDI_TypeKind;
|
||||
typedef enum RDI_TypeKindEnum{
|
||||
|
||||
#define X(name,code) RADDBGI_TypeKind_##name = code,
|
||||
#define X(name,code) RDI_TypeKind_##name = code,
|
||||
#define XZ(name,code,size) X(name,code)
|
||||
#define Y(alias_name,name) RADDBGI_TypeKind_##alias_name = RADDBGI_TypeKind_##name,
|
||||
RADDBGI_TypeKindXList(X,XZ,Y)
|
||||
#define Y(alias_name,name) RDI_TypeKind_##alias_name = RDI_TypeKind_##name,
|
||||
RDI_TypeKindXList(X,XZ,Y)
|
||||
#undef X
|
||||
#undef XZ
|
||||
#undef Y
|
||||
|
||||
} RADDBGI_TypeKindEnum;
|
||||
} RDI_TypeKindEnum;
|
||||
|
||||
typedef RADDBGI_U16 RADDBGI_TypeModifierFlags;
|
||||
typedef RDI_U16 RDI_TypeModifierFlags;
|
||||
enum{
|
||||
RADDBGI_TypeModifierFlag_Const = (1 << 0),
|
||||
RADDBGI_TypeModifierFlag_Volatile = (1 << 1),
|
||||
RDI_TypeModifierFlag_Const = (1 << 0),
|
||||
RDI_TypeModifierFlag_Volatile = (1 << 1),
|
||||
};
|
||||
|
||||
// IMPORTANT NOTE: All type nodes in a valid raddbg are *topologically sorted*.
|
||||
@@ -493,65 +499,65 @@ enum{
|
||||
// This restriction does not apply to the members of a type that are
|
||||
// attached through a "UDT" though.
|
||||
|
||||
typedef struct RADDBGI_TypeNode{
|
||||
RADDBGI_TypeKind kind;
|
||||
// when kind is 'Modifier' -> RADDBGI_TypeModifierFlags
|
||||
RADDBGI_U16 flags;
|
||||
typedef struct RDI_TypeNode{
|
||||
RDI_TypeKind kind;
|
||||
// when kind is 'Modifier' -> RDI_TypeModifierFlags
|
||||
RDI_U16 flags;
|
||||
|
||||
RADDBGI_U32 byte_size;
|
||||
RDI_U32 byte_size;
|
||||
|
||||
union{
|
||||
// kind is 'built-in'
|
||||
struct{
|
||||
RADDBGI_U32 name_string_idx;
|
||||
RDI_U32 name_string_idx;
|
||||
} built_in;
|
||||
|
||||
// kind is 'constructed'
|
||||
struct{
|
||||
RADDBGI_U32 direct_type_idx;
|
||||
RADDBGI_U32 count;
|
||||
RDI_U32 direct_type_idx;
|
||||
RDI_U32 count;
|
||||
union{
|
||||
// when kind is 'Function' or 'Method'
|
||||
RADDBGI_U32 param_idx_run_first;
|
||||
RDI_U32 param_idx_run_first;
|
||||
// when kind is 'MemberPtr'
|
||||
RADDBGI_U32 owner_type_idx;
|
||||
RDI_U32 owner_type_idx;
|
||||
};
|
||||
} constructed;
|
||||
|
||||
// kind is 'user defined'
|
||||
struct{
|
||||
RADDBGI_U32 name_string_idx;
|
||||
RADDBGI_U32 direct_type_idx;
|
||||
RADDBGI_U32 udt_idx;
|
||||
RDI_U32 name_string_idx;
|
||||
RDI_U32 direct_type_idx;
|
||||
RDI_U32 udt_idx;
|
||||
} user_defined;
|
||||
|
||||
// (kind = Bitfield)
|
||||
struct{
|
||||
RADDBGI_U32 off;
|
||||
RADDBGI_U32 size;
|
||||
RDI_U32 off;
|
||||
RDI_U32 size;
|
||||
} bitfield;
|
||||
};
|
||||
} RADDBGI_TypeNode;
|
||||
} RDI_TypeNode;
|
||||
|
||||
typedef RADDBGI_U32 RADDBGI_UserDefinedTypeFlags;
|
||||
typedef RDI_U32 RDI_UserDefinedTypeFlags;
|
||||
enum{
|
||||
RADDBGI_UserDefinedTypeFlag_EnumMembers = (1 << 0),
|
||||
RDI_UserDefinedTypeFlag_EnumMembers = (1 << 0),
|
||||
};
|
||||
|
||||
typedef struct RADDBGI_UDT{
|
||||
RADDBGI_U32 self_type_idx;
|
||||
RADDBGI_UserDefinedTypeFlags flags;
|
||||
typedef struct RDI_UDT{
|
||||
RDI_U32 self_type_idx;
|
||||
RDI_UserDefinedTypeFlags flags;
|
||||
|
||||
// when EnumMembers flag is set, indexes into enum "enum_members" instead of "members"
|
||||
RADDBGI_U32 member_first;
|
||||
RADDBGI_U32 member_count;
|
||||
RDI_U32 member_first;
|
||||
RDI_U32 member_count;
|
||||
|
||||
RADDBGI_U32 file_idx;
|
||||
RADDBGI_U32 line;
|
||||
RADDBGI_U32 col;
|
||||
} RADDBGI_UDT;
|
||||
RDI_U32 file_idx;
|
||||
RDI_U32 line;
|
||||
RDI_U32 col;
|
||||
} RDI_UDT;
|
||||
|
||||
#define RADDBGI_MemberKindXList(X) \
|
||||
#define RDI_MemberKindXList(X) \
|
||||
X(NULL, 0x0000) \
|
||||
X(DataField, 0x0001) \
|
||||
X(StaticData, 0x0002) \
|
||||
@@ -563,12 +569,12 @@ X(Base, 0x0201) \
|
||||
X(VirtualBase, 0x0202) \
|
||||
X(NestedType, 0x0300)
|
||||
|
||||
typedef RADDBGI_U16 RADDBGI_MemberKind;
|
||||
typedef enum RADDBGI_MemberKindEnum{
|
||||
#define X(N,C) RADDBGI_MemberKind_##N = C,
|
||||
RADDBGI_MemberKindXList(X)
|
||||
typedef RDI_U16 RDI_MemberKind;
|
||||
typedef enum RDI_MemberKindEnum{
|
||||
#define X(N,C) RDI_MemberKind_##N = C,
|
||||
RDI_MemberKindXList(X)
|
||||
#undef X
|
||||
} RADDBGI_MemberKindEnum;
|
||||
} RDI_MemberKindEnum;
|
||||
|
||||
// TODO(allen): need a way to equip methods and some virtual methods
|
||||
// with procedure symbol information. I'm thinking a seperate data
|
||||
@@ -578,141 +584,141 @@ typedef enum RADDBGI_MemberKindEnum{
|
||||
// like 'associate_method_to_proc' that can be used *after* both the
|
||||
// method and proc are known, rather than one that forces us to know
|
||||
// the association when constructing the member data.
|
||||
typedef struct RADDBGI_Member{
|
||||
RADDBGI_MemberKind kind;
|
||||
RADDBGI_U16 __unused__;
|
||||
typedef struct RDI_Member{
|
||||
RDI_MemberKind kind;
|
||||
RDI_U16 __unused__;
|
||||
|
||||
RADDBGI_U32 name_string_idx;
|
||||
RADDBGI_U32 type_idx;
|
||||
RADDBGI_U32 off;
|
||||
} RADDBGI_Member;
|
||||
RDI_U32 name_string_idx;
|
||||
RDI_U32 type_idx;
|
||||
RDI_U32 off;
|
||||
} RDI_Member;
|
||||
|
||||
typedef struct RADDBGI_EnumMember{
|
||||
RADDBGI_U32 name_string_idx;
|
||||
RADDBGI_U32 __unused__;
|
||||
RADDBGI_U64 val;
|
||||
} RADDBGI_EnumMember;
|
||||
typedef struct RDI_EnumMember{
|
||||
RDI_U32 name_string_idx;
|
||||
RDI_U32 __unused__;
|
||||
RDI_U64 val;
|
||||
} RDI_EnumMember;
|
||||
|
||||
|
||||
//- symbol info
|
||||
typedef RADDBGI_U32 RADDBGI_LinkFlags;
|
||||
typedef RDI_U32 RDI_LinkFlags;
|
||||
enum{
|
||||
RADDBGI_LinkFlag_External = (1 << 0),
|
||||
RDI_LinkFlag_External = (1 << 0),
|
||||
// NOTE: Scope flags are mutually exclusive.
|
||||
// A symbol is either global scoped, type scoped, or procedure scoped.
|
||||
RADDBGI_LinkFlag_TypeScoped = (1 << 1),
|
||||
RADDBGI_LinkFlag_ProcScoped = (1 << 2),
|
||||
RDI_LinkFlag_TypeScoped = (1 << 1),
|
||||
RDI_LinkFlag_ProcScoped = (1 << 2),
|
||||
};
|
||||
|
||||
typedef struct RADDBGI_GlobalVariable{
|
||||
RADDBGI_U32 name_string_idx;
|
||||
typedef struct RDI_GlobalVariable{
|
||||
RDI_U32 name_string_idx;
|
||||
// NOTE: "global variables" can be scoped in *any* way. The scope flags here refer to
|
||||
// *namespace* scoping. "global variables" are all in the data section of the
|
||||
// final exe/dll type file, so they are "global" in the life-time sense of the
|
||||
// word. In the namespace sense of the word, they can be scoped globally, by type,
|
||||
// or by procedure.
|
||||
RADDBGI_LinkFlags link_flags;
|
||||
RADDBGI_U64 voff;
|
||||
RADDBGI_U32 type_idx;
|
||||
RDI_LinkFlags link_flags;
|
||||
RDI_U64 voff;
|
||||
RDI_U32 type_idx;
|
||||
|
||||
// container_idx: UDT for "TypeScoped", Procedure for "ProcScoped"
|
||||
RADDBGI_U32 container_idx;
|
||||
} RADDBGI_GlobalVariable;
|
||||
RDI_U32 container_idx;
|
||||
} RDI_GlobalVariable;
|
||||
|
||||
typedef struct RADDBGI_ThreadVariable{
|
||||
RADDBGI_U32 name_string_idx;
|
||||
typedef struct RDI_ThreadVariable{
|
||||
RDI_U32 name_string_idx;
|
||||
// NOTE: See the note in GlobalVariable regarding scoping. The same concept applies here.
|
||||
RADDBGI_LinkFlags link_flags;
|
||||
RADDBGI_U32 tls_off;
|
||||
RADDBGI_U32 type_idx;
|
||||
RDI_LinkFlags link_flags;
|
||||
RDI_U32 tls_off;
|
||||
RDI_U32 type_idx;
|
||||
|
||||
// container_idx: UDT for "TypeScoped", Procedure for "ProcScoped"
|
||||
RADDBGI_U32 container_idx;
|
||||
} RADDBGI_ThreadVariable;
|
||||
RDI_U32 container_idx;
|
||||
} RDI_ThreadVariable;
|
||||
|
||||
typedef struct RADDBGI_Procedure{
|
||||
RADDBGI_U32 name_string_idx;
|
||||
RADDBGI_U32 link_name_string_idx;
|
||||
typedef struct RDI_Procedure{
|
||||
RDI_U32 name_string_idx;
|
||||
RDI_U32 link_name_string_idx;
|
||||
// NOTE: See the note in GlobalVariable regarding scoping. The same concept applies here.
|
||||
RADDBGI_LinkFlags link_flags;
|
||||
RADDBGI_U32 type_idx;
|
||||
RADDBGI_U32 root_scope_idx;
|
||||
RDI_LinkFlags link_flags;
|
||||
RDI_U32 type_idx;
|
||||
RDI_U32 root_scope_idx;
|
||||
|
||||
// container_idx: UDT for "TypeScoped", Procedure for "ProcScoped"
|
||||
RADDBGI_U32 container_idx;
|
||||
} RADDBGI_Procedure;
|
||||
RDI_U32 container_idx;
|
||||
} RDI_Procedure;
|
||||
|
||||
typedef struct RADDBGI_Scope{
|
||||
RADDBGI_U32 proc_idx;
|
||||
RADDBGI_U32 parent_scope_idx;
|
||||
RADDBGI_U32 first_child_scope_idx;
|
||||
RADDBGI_U32 next_sibling_scope_idx;
|
||||
typedef struct RDI_Scope{
|
||||
RDI_U32 proc_idx;
|
||||
RDI_U32 parent_scope_idx;
|
||||
RDI_U32 first_child_scope_idx;
|
||||
RDI_U32 next_sibling_scope_idx;
|
||||
|
||||
RADDBGI_U32 voff_range_first;
|
||||
RADDBGI_U32 voff_range_opl;
|
||||
RDI_U32 voff_range_first;
|
||||
RDI_U32 voff_range_opl;
|
||||
|
||||
// indexes into "locals"
|
||||
RADDBGI_U32 local_first;
|
||||
RADDBGI_U32 local_count;
|
||||
RDI_U32 local_first;
|
||||
RDI_U32 local_count;
|
||||
|
||||
RADDBGI_U32 static_local_idx_run_first;
|
||||
RADDBGI_U32 static_local_count;
|
||||
RDI_U32 static_local_idx_run_first;
|
||||
RDI_U32 static_local_count;
|
||||
|
||||
// TODO(allen): attach less common scope-relevant info
|
||||
} RADDBGI_Scope;
|
||||
} RDI_Scope;
|
||||
|
||||
typedef RADDBGI_U32 RADDBGI_LocalKind;
|
||||
typedef RDI_U32 RDI_LocalKind;
|
||||
typedef enum{
|
||||
RADDBGI_LocalKind_NULL,
|
||||
RADDBGI_LocalKind_Parameter,
|
||||
RADDBGI_LocalKind_Variable,
|
||||
RADDBGI_LocalKind_COUNT
|
||||
} RADDBGI_LocalKindEnum;
|
||||
RDI_LocalKind_NULL,
|
||||
RDI_LocalKind_Parameter,
|
||||
RDI_LocalKind_Variable,
|
||||
RDI_LocalKind_COUNT
|
||||
} RDI_LocalKindEnum;
|
||||
|
||||
typedef struct RADDBGI_Local{
|
||||
RADDBGI_LocalKind kind;
|
||||
RADDBGI_U32 name_string_idx;
|
||||
RADDBGI_U64 type_idx;
|
||||
typedef struct RDI_Local{
|
||||
RDI_LocalKind kind;
|
||||
RDI_U32 name_string_idx;
|
||||
RDI_U64 type_idx;
|
||||
// indexes into "location_blocks"
|
||||
RADDBGI_U32 location_first;
|
||||
RADDBGI_U32 location_opl;
|
||||
} RADDBGI_Local;
|
||||
RDI_U32 location_first;
|
||||
RDI_U32 location_opl;
|
||||
} RDI_Local;
|
||||
|
||||
typedef struct RADDBGI_LocationBlock{
|
||||
RADDBGI_U32 scope_off_first;
|
||||
RADDBGI_U32 scope_off_opl;
|
||||
RADDBGI_U32 location_data_off;
|
||||
} RADDBGI_LocationBlock;
|
||||
typedef struct RDI_LocationBlock{
|
||||
RDI_U32 scope_off_first;
|
||||
RDI_U32 scope_off_opl;
|
||||
RDI_U32 location_data_off;
|
||||
} RDI_LocationBlock;
|
||||
|
||||
typedef RADDBGI_U8 RADDBGI_LocationKind;
|
||||
typedef RDI_U8 RDI_LocationKind;
|
||||
typedef enum{
|
||||
RADDBGI_LocationKind_NULL,
|
||||
RADDBGI_LocationKind_AddrBytecodeStream,
|
||||
RADDBGI_LocationKind_ValBytecodeStream,
|
||||
RADDBGI_LocationKind_AddrRegisterPlusU16,
|
||||
RADDBGI_LocationKind_AddrAddrRegisterPlusU16,
|
||||
RADDBGI_LocationKind_ValRegister,
|
||||
RADDBGI_LocationKind_COUNT
|
||||
} RADDBGI_LocationKindEnum;
|
||||
RDI_LocationKind_NULL,
|
||||
RDI_LocationKind_AddrBytecodeStream,
|
||||
RDI_LocationKind_ValBytecodeStream,
|
||||
RDI_LocationKind_AddrRegisterPlusU16,
|
||||
RDI_LocationKind_AddrAddrRegisterPlusU16,
|
||||
RDI_LocationKind_ValRegister,
|
||||
RDI_LocationKind_COUNT
|
||||
} RDI_LocationKindEnum;
|
||||
|
||||
typedef struct RADDBGI_LocationBytecodeStream{
|
||||
RADDBGI_LocationKind kind;
|
||||
// [... 0] null terminated byte sequence RADDBGI_EvalBytecodeStream
|
||||
} RADDBGI_LocationBytecodeStream;
|
||||
typedef struct RDI_LocationBytecodeStream{
|
||||
RDI_LocationKind kind;
|
||||
// [... 0] null terminated byte sequence RDI_EvalBytecodeStream
|
||||
} RDI_LocationBytecodeStream;
|
||||
|
||||
typedef struct RADDBGI_LocationRegisterPlusU16{
|
||||
RADDBGI_LocationKind kind;
|
||||
RADDBGI_RegisterCode register_code;
|
||||
RADDBGI_U16 offset;
|
||||
} RADDBGI_LocationRegisterPlusU16;
|
||||
typedef struct RDI_LocationRegisterPlusU16{
|
||||
RDI_LocationKind kind;
|
||||
RDI_RegisterCode register_code;
|
||||
RDI_U16 offset;
|
||||
} RDI_LocationRegisterPlusU16;
|
||||
|
||||
typedef struct RADDBGI_LocationRegister{
|
||||
RADDBGI_LocationKind kind;
|
||||
RADDBGI_RegisterCode register_code;
|
||||
} RADDBGI_LocationRegister;
|
||||
typedef struct RDI_LocationRegister{
|
||||
RDI_LocationKind kind;
|
||||
RDI_RegisterCode register_code;
|
||||
} RDI_LocationRegister;
|
||||
|
||||
//- name map types
|
||||
#define RADDBGI_NameMapXList(X)\
|
||||
#define RDI_NameMapXList(X)\
|
||||
X(NULL, 0)\
|
||||
X(GlobalVariables, 1)\
|
||||
X(ThreadVariables, 2)\
|
||||
@@ -721,42 +727,42 @@ X(Types, 4)\
|
||||
X(LinkNameProcedures, 5)\
|
||||
X(NormalSourcePaths, 6)
|
||||
|
||||
typedef RADDBGI_U32 RADDBGI_NameMapKind;
|
||||
typedef enum RADDBGI_NameMapKindEnum{
|
||||
#define X(N,C) RADDBGI_NameMapKind_##N = C,
|
||||
RADDBGI_NameMapXList(X)
|
||||
typedef RDI_U32 RDI_NameMapKind;
|
||||
typedef enum RDI_NameMapKindEnum{
|
||||
#define X(N,C) RDI_NameMapKind_##N = C,
|
||||
RDI_NameMapXList(X)
|
||||
#undef X
|
||||
|
||||
RADDBGI_NameMapKind_COUNT
|
||||
} RADDBGI_NameMapKindEnum;
|
||||
RDI_NameMapKind_COUNT
|
||||
} RDI_NameMapKindEnum;
|
||||
|
||||
// TODO(allen): documentation here for the hashing and probing strategy for this table
|
||||
|
||||
typedef struct RADDBGI_NameMap{
|
||||
RADDBGI_NameMapKind kind;
|
||||
RADDBGI_U32 bucket_data_idx;
|
||||
RADDBGI_U32 node_data_idx;
|
||||
} RADDBGI_NameMap;
|
||||
typedef struct RDI_NameMap{
|
||||
RDI_NameMapKind kind;
|
||||
RDI_U32 bucket_data_idx;
|
||||
RDI_U32 node_data_idx;
|
||||
} RDI_NameMap;
|
||||
|
||||
typedef struct RADDBGI_NameMapBucket{
|
||||
RADDBGI_U32 first_node;
|
||||
RADDBGI_U32 node_count;
|
||||
} RADDBGI_NameMapBucket;
|
||||
typedef struct RDI_NameMapBucket{
|
||||
RDI_U32 first_node;
|
||||
RDI_U32 node_count;
|
||||
} RDI_NameMapBucket;
|
||||
|
||||
typedef struct RADDBGI_NameMapNode{
|
||||
RADDBGI_U32 string_idx;
|
||||
RADDBGI_U32 match_count;
|
||||
typedef struct RDI_NameMapNode{
|
||||
RDI_U32 string_idx;
|
||||
RDI_U32 match_count;
|
||||
// NOTE: if (match_count == 1) then this is the index of the matching item
|
||||
// if (match_count > 1) then this is the first for an index run of all the matches
|
||||
RADDBGI_U32 match_idx_or_idx_run_first;
|
||||
} RADDBGI_NameMapNode;
|
||||
RDI_U32 match_idx_or_idx_run_first;
|
||||
} RDI_NameMapNode;
|
||||
|
||||
|
||||
////////////////////////////////
|
||||
// Eval Bytecode
|
||||
|
||||
// (Name, decodeN, popN, pushN)
|
||||
#define RADDBGI_EvalOpXList(X)\
|
||||
#define RDI_EvalOpXList(X)\
|
||||
X(Stop, 0, 0, 0)\
|
||||
X(Noop, 0, 0, 0)\
|
||||
X(Cond, 1, 1, 0)\
|
||||
@@ -803,7 +809,7 @@ X(Pop, 0, 1, 0)\
|
||||
X(Insert, 1, 0, 0)
|
||||
|
||||
// (Name)
|
||||
#define RADDBGI_EvalTypeGroupXList(X)\
|
||||
#define RDI_EvalTypeGroupXList(X)\
|
||||
X(Other)\
|
||||
X(U)\
|
||||
X(S)\
|
||||
@@ -811,7 +817,7 @@ X(F32)\
|
||||
X(F64)
|
||||
|
||||
// (Name, error-message)
|
||||
#define RADDBGI_EvalConversionKindXList(X)\
|
||||
#define RDI_EvalConversionKindXList(X)\
|
||||
X(Noop, "")\
|
||||
X(Legal, "")\
|
||||
X(OtherToOther, "cannot convert between these types")\
|
||||
@@ -819,7 +825,7 @@ X(ToOther, "cannot convert to this type")\
|
||||
X(FromOther, "cannot convert this type")
|
||||
|
||||
// Xb(EvalTypeGroup) Y(TypeKind) Xe(EvalTypeGroup)
|
||||
#define RADDBGI_EvalTypeGroupFromKindMap(Y,Xb,Xe)\
|
||||
#define RDI_EvalTypeGroupFromKindMap(Y,Xb,Xe)\
|
||||
\
|
||||
Xb(U) Y(U8) Y(U16) Y(U32) Y(U64) Y(Bool) Y(Ptr) Y(Enum)\
|
||||
Xe(U)\
|
||||
@@ -834,7 +840,7 @@ Xb(F64) Y(F64)\
|
||||
Xe(F64)
|
||||
|
||||
// Xb(EvalConversionKind) Y(EvalTypeGroup, EvalTypeGroup) Xe(EvalConversionKind)
|
||||
#define RADDBGI_EvalConversionKindFromTypeGroupPairMap(Y,Xb,Xe)\
|
||||
#define RDI_EvalConversionKindFromTypeGroupPairMap(Y,Xb,Xe)\
|
||||
\
|
||||
Xb(Noop) Y(U, U) Y(S, S) Y(F32, F32) Y(F64, F64) Y(U, S) Y(S, U)\
|
||||
Xe(Noop)\
|
||||
@@ -855,65 +861,65 @@ Xb(FromOther) Y(Other, U) Y(Other, S) Y(Other, F32) Y(Other, F64)\
|
||||
Xe(FromOther)
|
||||
|
||||
// eval interpretation macros
|
||||
#define RADDBGI_EncodeRegReadParam(reg,bytesize,bytepos) ((reg)|((bytesize)<<8)|((bytepos)<<16))
|
||||
#define RDI_EncodeRegReadParam(reg,bytesize,bytepos) ((reg)|((bytesize)<<8)|((bytepos)<<16))
|
||||
|
||||
|
||||
// eval enums
|
||||
typedef RADDBGI_U8 RADDBGI_EvalOp;
|
||||
typedef RDI_U8 RDI_EvalOp;
|
||||
|
||||
typedef enum RADDBGI_EvalOpEnum{
|
||||
#define X(N,dec,pop,push) RADDBGI_EvalOp_##N,
|
||||
RADDBGI_EvalOpXList(X)
|
||||
typedef enum RDI_EvalOpEnum{
|
||||
#define X(N,dec,pop,push) RDI_EvalOp_##N,
|
||||
RDI_EvalOpXList(X)
|
||||
#undef X
|
||||
|
||||
RADDBGI_EvalOp_COUNT
|
||||
} RADDBGI_EvalOpEnum;
|
||||
RDI_EvalOp_COUNT
|
||||
} RDI_EvalOpEnum;
|
||||
|
||||
|
||||
typedef RADDBGI_U8 RADDBGI_EvalTypeGroup;
|
||||
typedef RDI_U8 RDI_EvalTypeGroup;
|
||||
|
||||
typedef enum RADDBGI_EvalTypeGroupEnum{
|
||||
#define X(N) RADDBGI_EvalTypeGroup_##N,
|
||||
RADDBGI_EvalTypeGroupXList(X)
|
||||
typedef enum RDI_EvalTypeGroupEnum{
|
||||
#define X(N) RDI_EvalTypeGroup_##N,
|
||||
RDI_EvalTypeGroupXList(X)
|
||||
#undef X
|
||||
RADDBGI_EvalTypeGroup_COUNT,
|
||||
} RADDBGI_EvalTypeGroupEnum;
|
||||
RDI_EvalTypeGroup_COUNT,
|
||||
} RDI_EvalTypeGroupEnum;
|
||||
|
||||
|
||||
typedef RADDBGI_U8 RADDBGI_EvalConversionKind;
|
||||
typedef RDI_U8 RDI_EvalConversionKind;
|
||||
|
||||
typedef enum RADDBGI_EvalConversionKindEnum{
|
||||
#define X(N,msg) RADDBGI_EvalConversionKind_##N,
|
||||
RADDBGI_EvalConversionKindXList(X)
|
||||
typedef enum RDI_EvalConversionKindEnum{
|
||||
#define X(N,msg) RDI_EvalConversionKind_##N,
|
||||
RDI_EvalConversionKindXList(X)
|
||||
#undef X
|
||||
RADDBGI_EvalConversionKind_COUNT,
|
||||
} RADDBGI_EvalConversionKindEnum;
|
||||
RDI_EvalConversionKind_COUNT,
|
||||
} RDI_EvalConversionKindEnum;
|
||||
|
||||
|
||||
//- eval data tables
|
||||
|
||||
#define RADDBGI_EVAL_CTRLBITS(decodeN,popN,pushN) ((decodeN) | ((popN) << 4) | ((pushN) << 6))
|
||||
#define RADDBGI_DECODEN_FROM_CTRLBITS(ctrlbits) ((ctrlbits) & 0xf)
|
||||
#define RADDBGI_POPN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 4) & 0x3)
|
||||
#define RADDBGI_PUSHN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 6) & 0x3)
|
||||
#define RDI_EVAL_CTRLBITS(decodeN,popN,pushN) ((decodeN) | ((popN) << 4) | ((pushN) << 6))
|
||||
#define RDI_DECODEN_FROM_CTRLBITS(ctrlbits) ((ctrlbits) & 0xf)
|
||||
#define RDI_POPN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 4) & 0x3)
|
||||
#define RDI_PUSHN_FROM_CTRLBITS(ctrlbits) (((ctrlbits) >> 6) & 0x3)
|
||||
|
||||
static RADDBGI_U8 raddbgi_eval_opcode_ctrlbits[] = {
|
||||
#define X(Name, decodeN, popN, pushN) RADDBGI_EVAL_CTRLBITS(decodeN,popN,pushN),
|
||||
RADDBGI_EvalOpXList(X)
|
||||
static RDI_U8 rdi_eval_opcode_ctrlbits[] = {
|
||||
#define X(Name, decodeN, popN, pushN) RDI_EVAL_CTRLBITS(decodeN,popN,pushN),
|
||||
RDI_EvalOpXList(X)
|
||||
#undef X
|
||||
};
|
||||
|
||||
////////////////////////////////
|
||||
// Functions
|
||||
|
||||
RADDBGI_PROC RADDBGI_U64 raddbgi_hash(RADDBGI_U8 *ptr, RADDBGI_U64 size);
|
||||
RADDBGI_PROC RADDBGI_U32 raddbgi_size_from_basic_type_kind(RADDBGI_TypeKind kind);
|
||||
RADDBGI_PROC RADDBGI_U32 raddbgi_addr_size_from_arch(RADDBGI_Arch arch);
|
||||
RDI_PROC RDI_U64 rdi_hash(RDI_U8 *ptr, RDI_U64 size);
|
||||
RDI_PROC RDI_U32 rdi_size_from_basic_type_kind(RDI_TypeKind kind);
|
||||
RDI_PROC RDI_U32 rdi_addr_size_from_arch(RDI_Arch arch);
|
||||
|
||||
//- eval helpers
|
||||
|
||||
RADDBGI_PROC RADDBGI_EvalConversionKind raddbgi_eval_conversion_rule(RADDBGI_EvalTypeGroup in, RADDBGI_EvalTypeGroup out);
|
||||
RADDBGI_PROC RADDBGI_U8* raddbgi_eval_conversion_message(RADDBGI_EvalConversionKind conversion_kind, RADDBGI_U64 *lennout);
|
||||
RADDBGI_PROC RADDBGI_S32 raddbgi_eval_opcode_type_compatible(RADDBGI_EvalOp op, RADDBGI_EvalTypeGroup group);
|
||||
RDI_PROC RDI_EvalConversionKind rdi_eval_conversion_rule(RDI_EvalTypeGroup in, RDI_EvalTypeGroup out);
|
||||
RDI_PROC RDI_U8* rdi_eval_conversion_message(RDI_EvalConversionKind conversion_kind, RDI_U64 *lennout);
|
||||
RDI_PROC RDI_S32 rdi_eval_opcode_type_compatible(RDI_EvalOp op, RDI_EvalTypeGroup group);
|
||||
|
||||
#endif // RADDBGI_FORMAT_H
|
||||
|
||||
@@ -4,105 +4,105 @@
|
||||
////////////////////////////////
|
||||
//~ RADDBG Parse API
|
||||
|
||||
RADDBGI_PROC RADDBGI_ParseStatus
|
||||
raddbgi_parse(RADDBGI_U8 *data, RADDBGI_U64 size, RADDBGI_Parsed *out){
|
||||
RADDBGI_ParseStatus result = RADDBGI_ParseStatus_Good;
|
||||
RDI_PROC RDI_ParseStatus
|
||||
rdi_parse(RDI_U8 *data, RDI_U64 size, RDI_Parsed *out){
|
||||
RDI_ParseStatus result = RDI_ParseStatus_Good;
|
||||
|
||||
// out header
|
||||
RADDBGI_Header *hdr = 0;
|
||||
RDI_Header *hdr = 0;
|
||||
{
|
||||
if (sizeof(*hdr) <= size){
|
||||
hdr = (RADDBGI_Header*)data;
|
||||
hdr = (RDI_Header*)data;
|
||||
}
|
||||
|
||||
// (errors)
|
||||
if (hdr == 0 || hdr->magic != RADDBGI_MAGIC_CONSTANT){
|
||||
if (hdr == 0 || hdr->magic != RDI_MAGIC_CONSTANT){
|
||||
hdr = 0;
|
||||
result = RADDBGI_ParseStatus_HeaderDoesNotMatch;
|
||||
result = RDI_ParseStatus_HeaderDoesNotMatch;
|
||||
}
|
||||
if (hdr != 0 && hdr->encoding_version != 1){
|
||||
hdr = 0;
|
||||
result = RADDBGI_ParseStatus_UnsupportedVersionNumber;
|
||||
result = RDI_ParseStatus_UnsupportedVersionNumber;
|
||||
}
|
||||
}
|
||||
|
||||
// out data sections
|
||||
RADDBGI_DataSection *dsecs = 0;
|
||||
RADDBGI_U32 dsec_count = 0;
|
||||
RDI_DataSection *dsecs = 0;
|
||||
RDI_U32 dsec_count = 0;
|
||||
if (hdr != 0){
|
||||
RADDBGI_U64 opl = (RADDBGI_U64)hdr->data_section_off + (RADDBGI_U64)hdr->data_section_count*sizeof(*dsecs);
|
||||
RDI_U64 opl = (RDI_U64)hdr->data_section_off + (RDI_U64)hdr->data_section_count*sizeof(*dsecs);
|
||||
if (opl <= size){
|
||||
dsecs = (RADDBGI_DataSection*)(data + hdr->data_section_off);
|
||||
dsecs = (RDI_DataSection*)(data + hdr->data_section_off);
|
||||
dsec_count = hdr->data_section_count;
|
||||
}
|
||||
|
||||
// (errors)
|
||||
if (dsecs == 0){
|
||||
result = RADDBGI_ParseStatus_InvalidDataSecionLayout;
|
||||
result = RDI_ParseStatus_InvalidDataSecionLayout;
|
||||
}
|
||||
}
|
||||
|
||||
// extract primary data section indexes
|
||||
RADDBGI_U32 dsec_idx[RADDBGI_DataSectionTag_PRIMARY_COUNT] = {0};
|
||||
if (result == RADDBGI_ParseStatus_Good){
|
||||
RADDBGI_DataSection *sec_ptr = dsecs;
|
||||
for (RADDBGI_U32 i = 0; i < dsec_count; i += 1, sec_ptr += 1){
|
||||
if (sec_ptr->tag < RADDBGI_DataSectionTag_PRIMARY_COUNT){
|
||||
RDI_U32 dsec_idx[RDI_DataSectionTag_PRIMARY_COUNT] = {0};
|
||||
if (result == RDI_ParseStatus_Good){
|
||||
RDI_DataSection *sec_ptr = dsecs;
|
||||
for (RDI_U32 i = 0; i < dsec_count; i += 1, sec_ptr += 1){
|
||||
if (sec_ptr->tag < RDI_DataSectionTag_PRIMARY_COUNT){
|
||||
dsec_idx[sec_ptr->tag] = i;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// fill out data block (part 1)
|
||||
if (result == RADDBGI_ParseStatus_Good){
|
||||
if (result == RDI_ParseStatus_Good){
|
||||
out->raw_data = data;
|
||||
out->raw_data_size = size;
|
||||
out->dsecs = dsecs;
|
||||
out->dsec_count = dsec_count;
|
||||
for (RADDBGI_U32 i = 0; i < RADDBGI_DataSectionTag_PRIMARY_COUNT; i += 1){
|
||||
for (RDI_U32 i = 0; i < RDI_DataSectionTag_PRIMARY_COUNT; i += 1){
|
||||
out->dsec_idx[i] = dsec_idx[i];
|
||||
}
|
||||
}
|
||||
|
||||
// out string table
|
||||
RADDBGI_U8 *string_data = 0;
|
||||
RADDBGI_U64 string_opl = 0;
|
||||
RADDBGI_U32 *string_offs = 0;
|
||||
RADDBGI_U64 string_count = 0;
|
||||
if (result == RADDBGI_ParseStatus_Good){
|
||||
raddbgi_parse__extract_primary(out, string_data, &string_opl,
|
||||
RADDBGI_DataSectionTag_StringData);
|
||||
RDI_U8 *string_data = 0;
|
||||
RDI_U64 string_opl = 0;
|
||||
RDI_U32 *string_offs = 0;
|
||||
RDI_U64 string_count = 0;
|
||||
if (result == RDI_ParseStatus_Good){
|
||||
rdi_parse__extract_primary(out, string_data, &string_opl,
|
||||
RDI_DataSectionTag_StringData);
|
||||
|
||||
RADDBGI_U64 table_entry_count = 0;
|
||||
raddbgi_parse__extract_primary(out, string_offs, &table_entry_count,
|
||||
RADDBGI_DataSectionTag_StringTable);
|
||||
RDI_U64 table_entry_count = 0;
|
||||
rdi_parse__extract_primary(out, string_offs, &table_entry_count,
|
||||
RDI_DataSectionTag_StringTable);
|
||||
if (table_entry_count > 0){
|
||||
string_count = table_entry_count - 1;
|
||||
}
|
||||
|
||||
// (errors)
|
||||
if (string_data == 0){
|
||||
result = RADDBGI_ParseStatus_MissingStringDataSection;
|
||||
result = RDI_ParseStatus_MissingStringDataSection;
|
||||
}
|
||||
else if (string_offs == 0){
|
||||
result = RADDBGI_ParseStatus_MissingStringTableSection;
|
||||
result = RDI_ParseStatus_MissingStringTableSection;
|
||||
}
|
||||
}
|
||||
|
||||
// out index runs
|
||||
RADDBGI_U32 *idx_run_data = 0;
|
||||
RADDBGI_U64 idx_run_count = 0;
|
||||
if (result == RADDBGI_ParseStatus_Good){
|
||||
raddbgi_parse__extract_primary(out, idx_run_data, &idx_run_count,
|
||||
RADDBGI_DataSectionTag_IndexRuns);
|
||||
RDI_U32 *idx_run_data = 0;
|
||||
RDI_U64 idx_run_count = 0;
|
||||
if (result == RDI_ParseStatus_Good){
|
||||
rdi_parse__extract_primary(out, idx_run_data, &idx_run_count,
|
||||
RDI_DataSectionTag_IndexRuns);
|
||||
|
||||
// (errors)
|
||||
if (idx_run_data == 0){
|
||||
result = RADDBGI_ParseStatus_MissingIndexRunSection;
|
||||
result = RDI_ParseStatus_MissingIndexRunSection;
|
||||
}
|
||||
}
|
||||
|
||||
if (result == RADDBGI_ParseStatus_Good){
|
||||
if (result == RDI_ParseStatus_Good){
|
||||
// fill out primary data structures (part 2)
|
||||
out->string_data = string_data;
|
||||
out->string_offs = string_offs;
|
||||
@@ -112,81 +112,81 @@ raddbgi_parse(RADDBGI_U8 *data, RADDBGI_U64 size, RADDBGI_Parsed *out){
|
||||
out->idx_run_count = idx_run_count;
|
||||
|
||||
{
|
||||
RADDBGI_TopLevelInfo *tli = 0;
|
||||
RADDBGI_U64 dummy = 0;
|
||||
raddbgi_parse__extract_primary(out, tli, &dummy, RADDBGI_DataSectionTag_TopLevelInfo);
|
||||
RDI_TopLevelInfo *tli = 0;
|
||||
RDI_U64 dummy = 0;
|
||||
rdi_parse__extract_primary(out, tli, &dummy, RDI_DataSectionTag_TopLevelInfo);
|
||||
if (dummy != 1){
|
||||
tli = 0;
|
||||
}
|
||||
out->top_level_info = tli;
|
||||
}
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->binary_sections, &out->binary_sections_count,
|
||||
RADDBGI_DataSectionTag_BinarySections);
|
||||
rdi_parse__extract_primary(out, out->binary_sections, &out->binary_sections_count,
|
||||
RDI_DataSectionTag_BinarySections);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->file_paths, &out->file_paths_count,
|
||||
RADDBGI_DataSectionTag_FilePathNodes);
|
||||
rdi_parse__extract_primary(out, out->file_paths, &out->file_paths_count,
|
||||
RDI_DataSectionTag_FilePathNodes);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->source_files, &out->source_files_count,
|
||||
RADDBGI_DataSectionTag_SourceFiles);
|
||||
rdi_parse__extract_primary(out, out->source_files, &out->source_files_count,
|
||||
RDI_DataSectionTag_SourceFiles);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->units, &out->units_count,
|
||||
RADDBGI_DataSectionTag_Units);
|
||||
rdi_parse__extract_primary(out, out->units, &out->units_count,
|
||||
RDI_DataSectionTag_Units);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->unit_vmap, &out->unit_vmap_count,
|
||||
RADDBGI_DataSectionTag_UnitVmap);
|
||||
rdi_parse__extract_primary(out, out->unit_vmap, &out->unit_vmap_count,
|
||||
RDI_DataSectionTag_UnitVmap);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->unit_vmap, &out->unit_vmap_count,
|
||||
RADDBGI_DataSectionTag_UnitVmap);
|
||||
rdi_parse__extract_primary(out, out->unit_vmap, &out->unit_vmap_count,
|
||||
RDI_DataSectionTag_UnitVmap);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->type_nodes, &out->type_nodes_count,
|
||||
RADDBGI_DataSectionTag_TypeNodes);
|
||||
rdi_parse__extract_primary(out, out->type_nodes, &out->type_nodes_count,
|
||||
RDI_DataSectionTag_TypeNodes);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->udts, &out->udts_count,
|
||||
RADDBGI_DataSectionTag_UDTs);
|
||||
rdi_parse__extract_primary(out, out->udts, &out->udts_count,
|
||||
RDI_DataSectionTag_UDTs);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->members, &out->members_count,
|
||||
RADDBGI_DataSectionTag_Members);
|
||||
rdi_parse__extract_primary(out, out->members, &out->members_count,
|
||||
RDI_DataSectionTag_Members);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->enum_members, &out->enum_members_count,
|
||||
RADDBGI_DataSectionTag_EnumMembers);
|
||||
rdi_parse__extract_primary(out, out->enum_members, &out->enum_members_count,
|
||||
RDI_DataSectionTag_EnumMembers);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->global_variables, &out->global_variables_count,
|
||||
RADDBGI_DataSectionTag_GlobalVariables);
|
||||
rdi_parse__extract_primary(out, out->global_variables, &out->global_variables_count,
|
||||
RDI_DataSectionTag_GlobalVariables);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->global_vmap, &out->global_vmap_count,
|
||||
RADDBGI_DataSectionTag_GlobalVmap);
|
||||
rdi_parse__extract_primary(out, out->global_vmap, &out->global_vmap_count,
|
||||
RDI_DataSectionTag_GlobalVmap);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->thread_variables, &out->thread_variables_count,
|
||||
RADDBGI_DataSectionTag_ThreadVariables);
|
||||
rdi_parse__extract_primary(out, out->thread_variables, &out->thread_variables_count,
|
||||
RDI_DataSectionTag_ThreadVariables);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->procedures, &out->procedures_count,
|
||||
RADDBGI_DataSectionTag_Procedures);
|
||||
rdi_parse__extract_primary(out, out->procedures, &out->procedures_count,
|
||||
RDI_DataSectionTag_Procedures);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->scopes, &out->scopes_count,
|
||||
RADDBGI_DataSectionTag_Scopes);
|
||||
rdi_parse__extract_primary(out, out->scopes, &out->scopes_count,
|
||||
RDI_DataSectionTag_Scopes);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->scope_voffs, &out->scope_voffs_count,
|
||||
RADDBGI_DataSectionTag_ScopeVoffData);
|
||||
rdi_parse__extract_primary(out, out->scope_voffs, &out->scope_voffs_count,
|
||||
RDI_DataSectionTag_ScopeVoffData);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->scope_vmap, &out->scope_vmap_count,
|
||||
RADDBGI_DataSectionTag_ScopeVmap);
|
||||
rdi_parse__extract_primary(out, out->scope_vmap, &out->scope_vmap_count,
|
||||
RDI_DataSectionTag_ScopeVmap);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->locals, &out->locals_count,
|
||||
RADDBGI_DataSectionTag_Locals);
|
||||
rdi_parse__extract_primary(out, out->locals, &out->locals_count,
|
||||
RDI_DataSectionTag_Locals);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->location_blocks, &out->location_blocks_count,
|
||||
RADDBGI_DataSectionTag_LocationBlocks);
|
||||
rdi_parse__extract_primary(out, out->location_blocks, &out->location_blocks_count,
|
||||
RDI_DataSectionTag_LocationBlocks);
|
||||
|
||||
raddbgi_parse__extract_primary(out, out->location_data, &out->location_data_size,
|
||||
RADDBGI_DataSectionTag_LocationData);
|
||||
rdi_parse__extract_primary(out, out->location_data, &out->location_data_size,
|
||||
RDI_DataSectionTag_LocationData);
|
||||
|
||||
{
|
||||
raddbgi_parse__extract_primary(out, out->name_maps, &out->name_maps_count,
|
||||
RADDBGI_DataSectionTag_NameMaps);
|
||||
rdi_parse__extract_primary(out, out->name_maps, &out->name_maps_count,
|
||||
RDI_DataSectionTag_NameMaps);
|
||||
|
||||
RADDBGI_NameMap *name_map_ptr = out->name_maps;
|
||||
RADDBGI_NameMap *name_map_opl = out->name_maps + out->name_maps_count;
|
||||
RDI_NameMap *name_map_ptr = out->name_maps;
|
||||
RDI_NameMap *name_map_opl = out->name_maps + out->name_maps_count;
|
||||
for (; name_map_ptr < name_map_opl; name_map_ptr += 1){
|
||||
if (out->name_maps_by_kind[name_map_ptr->kind] == 0){
|
||||
out->name_maps_by_kind[name_map_ptr->kind] = name_map_ptr;
|
||||
@@ -194,25 +194,25 @@ raddbgi_parse(RADDBGI_U8 *data, RADDBGI_U64 size, RADDBGI_Parsed *out){
|
||||
}
|
||||
}
|
||||
|
||||
#if !defined(RADDBGI_DISABLE_NILS)
|
||||
if(out->binary_sections == 0) { out->binary_sections = &raddbgi_binary_section_nil; out->binary_sections_count = 1; }
|
||||
if(out->file_paths == 0) { out->file_paths = &raddbgi_file_path_node_nil; out->file_paths_count = 1; }
|
||||
if(out->source_files == 0) { out->source_files = &raddbgi_source_file_nil; out->source_files_count = 1; }
|
||||
if(out->units == 0) { out->units = &raddbgi_unit_nil; out->units_count = 1; }
|
||||
if(out->unit_vmap == 0) { out->unit_vmap = &raddbgi_vmap_entry_nil; out->unit_vmap_count = 1; }
|
||||
if(out->type_nodes == 0) { out->type_nodes = &raddbgi_type_node_nil; out->type_nodes_count = 1; }
|
||||
if(out->udts == 0) { out->udts = &raddbgi_udt_nil; out->udts_count = 1; }
|
||||
if(out->members == 0) { out->members = &raddbgi_member_nil; out->members_count = 1; }
|
||||
if(out->enum_members == 0) { out->enum_members = &raddbgi_enum_member_nil; out->enum_members_count = 1; }
|
||||
if(out->global_variables == 0) { out->global_variables = &raddbgi_global_variable_nil; out->global_variables_count = 1; }
|
||||
if(out->global_vmap == 0) { out->global_vmap = &raddbgi_vmap_entry_nil; out->global_vmap_count = 1; }
|
||||
if(out->thread_variables == 0) { out->thread_variables = &raddbgi_thread_variable_nil; out->thread_variables_count = 1; }
|
||||
if(out->procedures == 0) { out->procedures = &raddbgi_procedure_nil; out->procedures_count = 1; }
|
||||
if(out->scopes == 0) { out->scopes = &raddbgi_scope_nil; out->scopes_count = 1; }
|
||||
if(out->scope_voffs == 0) { out->scope_voffs = &raddbgi_voff_nil; out->scope_voffs_count = 1; }
|
||||
if(out->scope_vmap == 0) { out->scope_vmap = &raddbgi_vmap_entry_nil; out->scope_vmap_count = 1; }
|
||||
if(out->locals == 0) { out->locals = &raddbgi_local_nil; out->locals_count = 1; }
|
||||
if(out->location_blocks == 0) { out->location_blocks = &raddbgi_location_block_nil; out->location_blocks_count = 1; }
|
||||
#if !defined(RDI_DISABLE_NILS)
|
||||
if(out->binary_sections == 0) { out->binary_sections = &rdi_binary_section_nil; out->binary_sections_count = 1; }
|
||||
if(out->file_paths == 0) { out->file_paths = &rdi_file_path_node_nil; out->file_paths_count = 1; }
|
||||
if(out->source_files == 0) { out->source_files = &rdi_source_file_nil; out->source_files_count = 1; }
|
||||
if(out->units == 0) { out->units = &rdi_unit_nil; out->units_count = 1; }
|
||||
if(out->unit_vmap == 0) { out->unit_vmap = &rdi_vmap_entry_nil; out->unit_vmap_count = 1; }
|
||||
if(out->type_nodes == 0) { out->type_nodes = &rdi_type_node_nil; out->type_nodes_count = 1; }
|
||||
if(out->udts == 0) { out->udts = &rdi_udt_nil; out->udts_count = 1; }
|
||||
if(out->members == 0) { out->members = &rdi_member_nil; out->members_count = 1; }
|
||||
if(out->enum_members == 0) { out->enum_members = &rdi_enum_member_nil; out->enum_members_count = 1; }
|
||||
if(out->global_variables == 0) { out->global_variables = &rdi_global_variable_nil; out->global_variables_count = 1; }
|
||||
if(out->global_vmap == 0) { out->global_vmap = &rdi_vmap_entry_nil; out->global_vmap_count = 1; }
|
||||
if(out->thread_variables == 0) { out->thread_variables = &rdi_thread_variable_nil; out->thread_variables_count = 1; }
|
||||
if(out->procedures == 0) { out->procedures = &rdi_procedure_nil; out->procedures_count = 1; }
|
||||
if(out->scopes == 0) { out->scopes = &rdi_scope_nil; out->scopes_count = 1; }
|
||||
if(out->scope_voffs == 0) { out->scope_voffs = &rdi_voff_nil; out->scope_voffs_count = 1; }
|
||||
if(out->scope_vmap == 0) { out->scope_vmap = &rdi_vmap_entry_nil; out->scope_vmap_count = 1; }
|
||||
if(out->locals == 0) { out->locals = &rdi_local_nil; out->locals_count = 1; }
|
||||
if(out->location_blocks == 0) { out->location_blocks = &rdi_location_block_nil; out->location_blocks_count = 1; }
|
||||
#endif
|
||||
|
||||
}
|
||||
@@ -220,15 +220,15 @@ raddbgi_parse(RADDBGI_U8 *data, RADDBGI_U64 size, RADDBGI_Parsed *out){
|
||||
return(result);
|
||||
}
|
||||
|
||||
RADDBGI_PROC RADDBGI_U8*
|
||||
raddbgi_string_from_idx(RADDBGI_Parsed *parsed, RADDBGI_U32 idx, RADDBGI_U64 *len_out){
|
||||
RADDBGI_U8 *result = 0;
|
||||
RADDBGI_U64 len_result = 0;
|
||||
RDI_PROC RDI_U8*
|
||||
rdi_string_from_idx(RDI_Parsed *parsed, RDI_U32 idx, RDI_U64 *len_out){
|
||||
RDI_U8 *result = 0;
|
||||
RDI_U64 len_result = 0;
|
||||
if (idx < parsed->string_count){
|
||||
RADDBGI_U32 off_raw = parsed->string_offs[idx];
|
||||
RADDBGI_U32 opl_raw = parsed->string_offs[idx + 1];
|
||||
RADDBGI_U32 opl = raddbgi_parse__min(opl_raw, parsed->string_data_size);
|
||||
RADDBGI_U32 off = raddbgi_parse__min(off_raw, opl);
|
||||
RDI_U32 off_raw = parsed->string_offs[idx];
|
||||
RDI_U32 opl_raw = parsed->string_offs[idx + 1];
|
||||
RDI_U32 opl = rdi_parse__min(opl_raw, parsed->string_data_size);
|
||||
RDI_U32 off = rdi_parse__min(off_raw, opl);
|
||||
result = parsed->string_data + off;
|
||||
len_result = opl - off;
|
||||
}
|
||||
@@ -236,15 +236,15 @@ raddbgi_string_from_idx(RADDBGI_Parsed *parsed, RADDBGI_U32 idx, RADDBGI_U64 *le
|
||||
return(result);
|
||||
}
|
||||
|
||||
RADDBGI_PROC RADDBGI_U32*
|
||||
raddbgi_idx_run_from_first_count(RADDBGI_Parsed *parsed,
|
||||
RADDBGI_U32 raw_first, RADDBGI_U32 raw_count,
|
||||
RADDBGI_U32 *n_out){
|
||||
RADDBGI_U32 raw_opl = raw_first + raw_count;
|
||||
RADDBGI_U32 opl = raddbgi_parse__min(raw_opl, parsed->idx_run_count);
|
||||
RADDBGI_U32 first = raddbgi_parse__min(raw_first, opl);
|
||||
RDI_PROC RDI_U32*
|
||||
rdi_idx_run_from_first_count(RDI_Parsed *parsed,
|
||||
RDI_U32 raw_first, RDI_U32 raw_count,
|
||||
RDI_U32 *n_out){
|
||||
RDI_U32 raw_opl = raw_first + raw_count;
|
||||
RDI_U32 opl = rdi_parse__min(raw_opl, parsed->idx_run_count);
|
||||
RDI_U32 first = rdi_parse__min(raw_first, opl);
|
||||
|
||||
RADDBGI_U32 *result = 0;
|
||||
RDI_U32 *result = 0;
|
||||
if (first < parsed->idx_run_count){
|
||||
result = parsed->idx_run_data + first;
|
||||
}
|
||||
@@ -254,29 +254,29 @@ raddbgi_idx_run_from_first_count(RADDBGI_Parsed *parsed,
|
||||
|
||||
//- line info
|
||||
|
||||
RADDBGI_PROC void
|
||||
raddbgi_line_info_from_unit(RADDBGI_Parsed *p, RADDBGI_Unit *unit, RADDBGI_ParsedLineInfo *out){
|
||||
RADDBGI_U64 line_info_voff_count = 0;
|
||||
RADDBGI_U64 *voffs = (RADDBGI_U64*)
|
||||
raddbgi_data_from_dsec(p, unit->line_info_voffs_data_idx, sizeof(RADDBGI_U64),
|
||||
RADDBGI_DataSectionTag_LineInfoVoffs,
|
||||
&line_info_voff_count);
|
||||
RDI_PROC void
|
||||
rdi_line_info_from_unit(RDI_Parsed *p, RDI_Unit *unit, RDI_ParsedLineInfo *out){
|
||||
RDI_U64 line_info_voff_count = 0;
|
||||
RDI_U64 *voffs = (RDI_U64*)
|
||||
rdi_data_from_dsec(p, unit->line_info_voffs_data_idx, sizeof(RDI_U64),
|
||||
RDI_DataSectionTag_LineInfoVoffs,
|
||||
&line_info_voff_count);
|
||||
|
||||
RADDBGI_U64 line_info_count_raw = 0;
|
||||
RADDBGI_Line *lines = (RADDBGI_Line*)
|
||||
raddbgi_data_from_dsec(p, unit->line_info_data_idx, sizeof(RADDBGI_Line),
|
||||
RADDBGI_DataSectionTag_LineInfoData,
|
||||
&line_info_count_raw);
|
||||
RDI_U64 line_info_count_raw = 0;
|
||||
RDI_Line *lines = (RDI_Line*)
|
||||
rdi_data_from_dsec(p, unit->line_info_data_idx, sizeof(RDI_Line),
|
||||
RDI_DataSectionTag_LineInfoData,
|
||||
&line_info_count_raw);
|
||||
|
||||
RADDBGI_U64 column_info_count_raw = 0;
|
||||
RADDBGI_Column *cols = (RADDBGI_Column*)
|
||||
raddbgi_data_from_dsec(p, unit->line_info_col_data_idx, sizeof(RADDBGI_Column),
|
||||
RADDBGI_DataSectionTag_LineInfoColumns,
|
||||
&column_info_count_raw);
|
||||
RDI_U64 column_info_count_raw = 0;
|
||||
RDI_Column *cols = (RDI_Column*)
|
||||
rdi_data_from_dsec(p, unit->line_info_col_data_idx, sizeof(RDI_Column),
|
||||
RDI_DataSectionTag_LineInfoColumns,
|
||||
&column_info_count_raw);
|
||||
|
||||
RADDBGI_U32 line_info_count_a = (line_info_voff_count > 0)?line_info_voff_count - 1:0;
|
||||
RADDBGI_U32 line_info_count = raddbgi_parse__min(line_info_count_a, line_info_count_raw);
|
||||
RADDBGI_U32 column_info_count = raddbgi_parse__min(column_info_count_raw, line_info_count);
|
||||
RDI_U32 line_info_count_a = (line_info_voff_count > 0)?line_info_voff_count - 1:0;
|
||||
RDI_U32 line_info_count = rdi_parse__min(line_info_count_a, line_info_count_raw);
|
||||
RDI_U32 column_info_count = rdi_parse__min(column_info_count_raw, line_info_count);
|
||||
|
||||
out->voffs = voffs;
|
||||
out->lines = lines;
|
||||
@@ -285,17 +285,17 @@ raddbgi_line_info_from_unit(RADDBGI_Parsed *p, RADDBGI_Unit *unit, RADDBGI_Parse
|
||||
out->col_count = column_info_count;
|
||||
}
|
||||
|
||||
RADDBGI_PROC RADDBGI_U64
|
||||
raddbgi_line_info_idx_from_voff(RADDBGI_ParsedLineInfo *line_info, RADDBGI_U64 voff)
|
||||
RDI_PROC RDI_U64
|
||||
rdi_line_info_idx_from_voff(RDI_ParsedLineInfo *line_info, RDI_U64 voff)
|
||||
{
|
||||
RADDBGI_U64 result = 0;
|
||||
RDI_U64 result = 0;
|
||||
if (line_info->count > 0 && line_info->voffs[0] <= voff && voff < line_info->voffs[line_info->count - 1]){
|
||||
// assuming: (i < j) -> (vmap[i].voff < vmap[j].voff)
|
||||
// find i such that: (vmap[i].voff <= voff) && (voff < vmap[i + 1].voff)
|
||||
RADDBGI_U32 first = 0;
|
||||
RADDBGI_U32 opl = line_info->count;
|
||||
RDI_U32 first = 0;
|
||||
RDI_U32 opl = line_info->count;
|
||||
for (;;){
|
||||
RADDBGI_U32 mid = (first + opl)/2;
|
||||
RDI_U32 mid = (first + opl)/2;
|
||||
if (line_info->voffs[mid] < voff){
|
||||
first = mid;
|
||||
}
|
||||
@@ -310,35 +310,35 @@ raddbgi_line_info_idx_from_voff(RADDBGI_ParsedLineInfo *line_info, RADDBGI_U64 v
|
||||
break;
|
||||
}
|
||||
}
|
||||
result = (RADDBGI_U64)first;
|
||||
result = (RDI_U64)first;
|
||||
}
|
||||
return(result);
|
||||
}
|
||||
|
||||
RADDBGI_PROC void
|
||||
raddbgi_line_map_from_source_file(RADDBGI_Parsed *p, RADDBGI_SourceFile *srcfile,
|
||||
RADDBGI_ParsedLineMap *out){
|
||||
RADDBGI_U64 num_count = 0;
|
||||
RADDBGI_U32 *nums = (RADDBGI_U32*)
|
||||
raddbgi_data_from_dsec(p, srcfile->line_map_nums_data_idx, sizeof(RADDBGI_U32),
|
||||
RADDBGI_DataSectionTag_LineMapNumbers,
|
||||
&num_count);
|
||||
RDI_PROC void
|
||||
rdi_line_map_from_source_file(RDI_Parsed *p, RDI_SourceFile *srcfile,
|
||||
RDI_ParsedLineMap *out){
|
||||
RDI_U64 num_count = 0;
|
||||
RDI_U32 *nums = (RDI_U32*)
|
||||
rdi_data_from_dsec(p, srcfile->line_map_nums_data_idx, sizeof(RDI_U32),
|
||||
RDI_DataSectionTag_LineMapNumbers,
|
||||
&num_count);
|
||||
|
||||
RADDBGI_U64 range_count = 0;
|
||||
RADDBGI_U32 *ranges = (RADDBGI_U32*)
|
||||
raddbgi_data_from_dsec(p, srcfile->line_map_range_data_idx, sizeof(RADDBGI_U32),
|
||||
RADDBGI_DataSectionTag_LineMapRanges,
|
||||
&range_count);
|
||||
RDI_U64 range_count = 0;
|
||||
RDI_U32 *ranges = (RDI_U32*)
|
||||
rdi_data_from_dsec(p, srcfile->line_map_range_data_idx, sizeof(RDI_U32),
|
||||
RDI_DataSectionTag_LineMapRanges,
|
||||
&range_count);
|
||||
|
||||
RADDBGI_U64 voff_count = 0;
|
||||
RADDBGI_U64 *voffs = (RADDBGI_U64*)
|
||||
raddbgi_data_from_dsec(p, srcfile->line_map_voff_data_idx, sizeof(RADDBGI_U64),
|
||||
RADDBGI_DataSectionTag_LineMapVoffs,
|
||||
&voff_count);
|
||||
RDI_U64 voff_count = 0;
|
||||
RDI_U64 *voffs = (RDI_U64*)
|
||||
rdi_data_from_dsec(p, srcfile->line_map_voff_data_idx, sizeof(RDI_U64),
|
||||
RDI_DataSectionTag_LineMapVoffs,
|
||||
&voff_count);
|
||||
|
||||
RADDBGI_U32 count_a = (range_count > 0)?(range_count - 1):0;
|
||||
RADDBGI_U32 count_b = raddbgi_parse__min(count_a, num_count);
|
||||
RADDBGI_U32 count = raddbgi_parse__min(count_b, srcfile->line_map_count);
|
||||
RDI_U32 count_a = (range_count > 0)?(range_count - 1):0;
|
||||
RDI_U32 count_b = rdi_parse__min(count_a, num_count);
|
||||
RDI_U32 count = rdi_parse__min(count_b, srcfile->line_map_count);
|
||||
|
||||
out->nums = nums;
|
||||
out->ranges = ranges;
|
||||
@@ -347,20 +347,20 @@ raddbgi_line_map_from_source_file(RADDBGI_Parsed *p, RADDBGI_SourceFile *srcfile
|
||||
out->voff_count = voff_count;
|
||||
}
|
||||
|
||||
RADDBGI_PROC RADDBGI_U64*
|
||||
raddbgi_line_voffs_from_num(RADDBGI_ParsedLineMap *map, RADDBGI_U32 linenum, RADDBGI_U32 *n_out){
|
||||
RADDBGI_U64 *result = 0;
|
||||
RDI_PROC RDI_U64*
|
||||
rdi_line_voffs_from_num(RDI_ParsedLineMap *map, RDI_U32 linenum, RDI_U32 *n_out){
|
||||
RDI_U64 *result = 0;
|
||||
*n_out = 0;
|
||||
|
||||
RADDBGI_U32 closest_i = 0;
|
||||
RDI_U32 closest_i = 0;
|
||||
if (map->count > 0 && map->nums[0] <= linenum){
|
||||
// assuming: (i < j) -> (nums[i] < nums[j])
|
||||
// find i such that: (nums[i] <= linenum) && (linenum < nums[i + 1])
|
||||
RADDBGI_U32 *nums = map->nums;
|
||||
RADDBGI_U32 first = 0;
|
||||
RADDBGI_U32 opl = map->count;
|
||||
RDI_U32 *nums = map->nums;
|
||||
RDI_U32 first = 0;
|
||||
RDI_U32 opl = map->count;
|
||||
for (;;){
|
||||
RADDBGI_U32 mid = (first + opl)/2;
|
||||
RDI_U32 mid = (first + opl)/2;
|
||||
if (nums[mid] < linenum){
|
||||
first = mid;
|
||||
}
|
||||
@@ -386,8 +386,8 @@ raddbgi_line_voffs_from_num(RADDBGI_ParsedLineMap *map, RADDBGI_U32 linenum, RAD
|
||||
|
||||
// set result if possible
|
||||
if (closest_i < map->count){
|
||||
RADDBGI_U32 first = map->ranges[closest_i];
|
||||
RADDBGI_U32 opl = map->ranges[closest_i + 1];
|
||||
RDI_U32 first = map->ranges[closest_i];
|
||||
RDI_U32 opl = map->ranges[closest_i + 1];
|
||||
if (opl < map->voff_count){
|
||||
result = map->voffs + first;
|
||||
*n_out = opl - first;
|
||||
@@ -400,16 +400,16 @@ raddbgi_line_voffs_from_num(RADDBGI_ParsedLineMap *map, RADDBGI_U32 linenum, RAD
|
||||
|
||||
//- vmaps
|
||||
|
||||
RADDBGI_PROC RADDBGI_U64
|
||||
raddbgi_vmap_idx_from_voff(RADDBGI_VMapEntry *vmap, RADDBGI_U32 vmap_count, RADDBGI_U64 voff){
|
||||
RADDBGI_U64 result = 0;
|
||||
RDI_PROC RDI_U64
|
||||
rdi_vmap_idx_from_voff(RDI_VMapEntry *vmap, RDI_U32 vmap_count, RDI_U64 voff){
|
||||
RDI_U64 result = 0;
|
||||
if (vmap_count > 0 && vmap[0].voff <= voff && voff < vmap[vmap_count - 1].voff){
|
||||
// assuming: (i < j) -> (vmap[i].voff < vmap[j].voff)
|
||||
// find i such that: (vmap[i].voff <= voff) && (voff < vmap[i + 1].voff)
|
||||
RADDBGI_U32 first = 0;
|
||||
RADDBGI_U32 opl = vmap_count;
|
||||
RDI_U32 first = 0;
|
||||
RDI_U32 opl = vmap_count;
|
||||
for (;;){
|
||||
RADDBGI_U32 mid = (first + opl)/2;
|
||||
RDI_U32 mid = (first + opl)/2;
|
||||
if (vmap[mid].voff < voff){
|
||||
first = mid;
|
||||
}
|
||||
@@ -424,60 +424,60 @@ raddbgi_vmap_idx_from_voff(RADDBGI_VMapEntry *vmap, RADDBGI_U32 vmap_count, RADD
|
||||
break;
|
||||
}
|
||||
}
|
||||
result = (RADDBGI_U64)vmap[first].idx;
|
||||
result = (RDI_U64)vmap[first].idx;
|
||||
}
|
||||
return(result);
|
||||
}
|
||||
|
||||
//- name maps
|
||||
|
||||
RADDBGI_PROC RADDBGI_NameMap*
|
||||
raddbgi_name_map_from_kind(RADDBGI_Parsed *p, RADDBGI_NameMapKind kind){
|
||||
RADDBGI_NameMap *result = 0;
|
||||
if (0 < kind && kind < RADDBGI_NameMapKind_COUNT){
|
||||
RDI_PROC RDI_NameMap*
|
||||
rdi_name_map_from_kind(RDI_Parsed *p, RDI_NameMapKind kind){
|
||||
RDI_NameMap *result = 0;
|
||||
if (0 < kind && kind < RDI_NameMapKind_COUNT){
|
||||
result = p->name_maps_by_kind[kind];
|
||||
}
|
||||
return(result);
|
||||
}
|
||||
|
||||
RADDBGI_PROC void
|
||||
raddbgi_name_map_parse(RADDBGI_Parsed *p, RADDBGI_NameMap *mapptr, RADDBGI_ParsedNameMap *out){
|
||||
RDI_PROC void
|
||||
rdi_name_map_parse(RDI_Parsed *p, RDI_NameMap *mapptr, RDI_ParsedNameMap *out){
|
||||
out->buckets = 0;
|
||||
out->bucket_count = 0;
|
||||
if (mapptr != 0){
|
||||
out->buckets = (RADDBGI_NameMapBucket*)
|
||||
raddbgi_data_from_dsec(p, mapptr->bucket_data_idx, sizeof(RADDBGI_NameMapBucket),
|
||||
RADDBGI_DataSectionTag_NameMapBuckets, &out->bucket_count);
|
||||
out->nodes = (RADDBGI_NameMapNode*)
|
||||
raddbgi_data_from_dsec(p, mapptr->node_data_idx, sizeof(RADDBGI_NameMapNode),
|
||||
RADDBGI_DataSectionTag_NameMapNodes, &out->node_count);
|
||||
out->buckets = (RDI_NameMapBucket*)
|
||||
rdi_data_from_dsec(p, mapptr->bucket_data_idx, sizeof(RDI_NameMapBucket),
|
||||
RDI_DataSectionTag_NameMapBuckets, &out->bucket_count);
|
||||
out->nodes = (RDI_NameMapNode*)
|
||||
rdi_data_from_dsec(p, mapptr->node_data_idx, sizeof(RDI_NameMapNode),
|
||||
RDI_DataSectionTag_NameMapNodes, &out->node_count);
|
||||
}
|
||||
}
|
||||
|
||||
RADDBGI_PROC RADDBGI_NameMapNode*
|
||||
raddbgi_name_map_lookup(RADDBGI_Parsed *p, RADDBGI_ParsedNameMap *map,
|
||||
RADDBGI_U8 *str, RADDBGI_U64 len){
|
||||
RADDBGI_NameMapNode *result = 0;
|
||||
RDI_PROC RDI_NameMapNode*
|
||||
rdi_name_map_lookup(RDI_Parsed *p, RDI_ParsedNameMap *map,
|
||||
RDI_U8 *str, RDI_U64 len){
|
||||
RDI_NameMapNode *result = 0;
|
||||
if (map->bucket_count > 0){
|
||||
RADDBGI_NameMapBucket *buckets = map->buckets;
|
||||
RADDBGI_U64 bucket_count = map->bucket_count;
|
||||
RADDBGI_U64 hash = raddbgi_hash(str, len);
|
||||
RADDBGI_U64 bucket_index = hash%bucket_count;
|
||||
RADDBGI_NameMapBucket *bucket = map->buckets + bucket_index;
|
||||
RDI_NameMapBucket *buckets = map->buckets;
|
||||
RDI_U64 bucket_count = map->bucket_count;
|
||||
RDI_U64 hash = rdi_hash(str, len);
|
||||
RDI_U64 bucket_index = hash%bucket_count;
|
||||
RDI_NameMapBucket *bucket = map->buckets + bucket_index;
|
||||
|
||||
RADDBGI_NameMapNode *node = map->nodes + bucket->first_node;
|
||||
RADDBGI_NameMapNode *node_opl = node + bucket->node_count;
|
||||
RDI_NameMapNode *node = map->nodes + bucket->first_node;
|
||||
RDI_NameMapNode *node_opl = node + bucket->node_count;
|
||||
for (;node < node_opl; node += 1){
|
||||
// extract a string from this node
|
||||
RADDBGI_U64 nlen = 0;
|
||||
RADDBGI_U8 *nstr = raddbgi_string_from_idx(p, node->string_idx, &nlen);
|
||||
RDI_U64 nlen = 0;
|
||||
RDI_U8 *nstr = rdi_string_from_idx(p, node->string_idx, &nlen);
|
||||
|
||||
// compare this to the needle string
|
||||
RADDBGI_S32 match = 0;
|
||||
RDI_S32 match = 0;
|
||||
if (nlen == len){
|
||||
RADDBGI_U8 *a = str;
|
||||
RADDBGI_U8 *aopl = str + len;
|
||||
RADDBGI_U8 *b = nstr;
|
||||
RDI_U8 *a = str;
|
||||
RDI_U8 *aopl = str + len;
|
||||
RDI_U8 *b = nstr;
|
||||
for (;a < aopl && *a == *b; a += 1, b += 1);
|
||||
match = (a == aopl);
|
||||
}
|
||||
@@ -493,10 +493,10 @@ raddbgi_name_map_lookup(RADDBGI_Parsed *p, RADDBGI_ParsedNameMap *map,
|
||||
return(result);
|
||||
}
|
||||
|
||||
RADDBGI_PROC RADDBGI_U32*
|
||||
raddbgi_matches_from_map_node(RADDBGI_Parsed *p, RADDBGI_NameMapNode *node,
|
||||
RADDBGI_U32 *n_out){
|
||||
RADDBGI_U32 *result = 0;
|
||||
RDI_PROC RDI_U32*
|
||||
rdi_matches_from_map_node(RDI_Parsed *p, RDI_NameMapNode *node,
|
||||
RDI_U32 *n_out){
|
||||
RDI_U32 *result = 0;
|
||||
*n_out = 0;
|
||||
if (node != 0){
|
||||
if (node->match_count == 1){
|
||||
@@ -504,8 +504,8 @@ raddbgi_matches_from_map_node(RADDBGI_Parsed *p, RADDBGI_NameMapNode *node,
|
||||
*n_out = 1;
|
||||
}
|
||||
else{
|
||||
result = raddbgi_idx_run_from_first_count(p, node->match_idx_or_idx_run_first,
|
||||
node->match_count, n_out);
|
||||
result = rdi_idx_run_from_first_count(p, node->match_idx_or_idx_run_first,
|
||||
node->match_count, n_out);
|
||||
}
|
||||
}
|
||||
return(result);
|
||||
@@ -513,14 +513,14 @@ raddbgi_matches_from_map_node(RADDBGI_Parsed *p, RADDBGI_NameMapNode *node,
|
||||
|
||||
//- common helpers
|
||||
|
||||
RADDBGI_PROC RADDBGI_U64
|
||||
raddbgi_first_voff_from_proc(RADDBGI_Parsed *p, RADDBGI_U32 proc_id){
|
||||
RADDBGI_U64 result = 0;
|
||||
RDI_PROC RDI_U64
|
||||
rdi_first_voff_from_proc(RDI_Parsed *p, RDI_U32 proc_id){
|
||||
RDI_U64 result = 0;
|
||||
if (0 < proc_id && proc_id < p->procedures_count){
|
||||
RADDBGI_Procedure *proc = p->procedures + proc_id;
|
||||
RADDBGI_U32 scope_id = proc->root_scope_idx;
|
||||
RDI_Procedure *proc = p->procedures + proc_id;
|
||||
RDI_U32 scope_id = proc->root_scope_idx;
|
||||
if (0 < scope_id && scope_id < p->scopes_count){
|
||||
RADDBGI_Scope *scope = p->scopes + scope_id;
|
||||
RDI_Scope *scope = p->scopes + scope_id;
|
||||
if (scope->voff_range_first < scope->voff_range_opl &&
|
||||
scope->voff_range_first < p->scope_voffs_count){
|
||||
result = p->scope_voffs[scope->voff_range_first];
|
||||
@@ -533,19 +533,19 @@ raddbgi_first_voff_from_proc(RADDBGI_Parsed *p, RADDBGI_U32 proc_id){
|
||||
////////////////////////////////
|
||||
//~ RADDBG Parsing Helpers
|
||||
|
||||
RADDBGI_PROC void*
|
||||
raddbgi_data_from_dsec(RADDBGI_Parsed *parsed, RADDBGI_U32 idx, RADDBGI_U32 item_size,
|
||||
RADDBGI_DataSectionTag expected_tag,
|
||||
RADDBGI_U64 *count_out){
|
||||
RDI_PROC void*
|
||||
rdi_data_from_dsec(RDI_Parsed *parsed, RDI_U32 idx, RDI_U32 item_size,
|
||||
RDI_DataSectionTag expected_tag,
|
||||
RDI_U64 *count_out){
|
||||
void *result = 0;
|
||||
RADDBGI_U32 count_result = 0;
|
||||
RDI_U32 count_result = 0;
|
||||
|
||||
// TODO(allen): need a version of this that works with encodings other than "Unpacked"
|
||||
|
||||
if (0 < idx && idx < parsed->dsec_count){
|
||||
RADDBGI_DataSection *ds = parsed->dsecs + idx;
|
||||
RDI_DataSection *ds = parsed->dsecs + idx;
|
||||
if (ds->tag == expected_tag){
|
||||
RADDBGI_U64 opl = ds->off + ds->encoded_size;
|
||||
RDI_U64 opl = ds->off + ds->encoded_size;
|
||||
if (opl <= parsed->raw_data_size){
|
||||
count_result = ds->encoded_size/item_size;
|
||||
result = (parsed->raw_data + ds->off);
|
||||
|
||||
@@ -1,105 +1,105 @@
|
||||
// Copyright (c) 2024 Epic Games Tools
|
||||
// Licensed under the MIT license (https://opensource.org/license/mit/)
|
||||
|
||||
#ifndef RADDBGI_PARSE_H
|
||||
#define RADDBGI_PARSE_H
|
||||
#ifndef RDI_PARSE_H
|
||||
#define RDI_PARSE_H
|
||||
|
||||
////////////////////////////////
|
||||
//~ RADDBG Parsing Helpers
|
||||
|
||||
typedef struct RADDBGI_Parsed{
|
||||
typedef struct RDI_Parsed{
|
||||
// raw data & data sections (part 1)
|
||||
RADDBGI_U8 *raw_data;
|
||||
RADDBGI_U64 raw_data_size;
|
||||
RADDBGI_DataSection *dsecs;
|
||||
RADDBGI_U64 dsec_count;
|
||||
RADDBGI_U32 dsec_idx[RADDBGI_DataSectionTag_PRIMARY_COUNT];
|
||||
RDI_U8 *raw_data;
|
||||
RDI_U64 raw_data_size;
|
||||
RDI_DataSection *dsecs;
|
||||
RDI_U64 dsec_count;
|
||||
RDI_U32 dsec_idx[RDI_DataSectionTag_PRIMARY_COUNT];
|
||||
|
||||
// primary data structures (part 2)
|
||||
|
||||
// handled by helper APIs
|
||||
RADDBGI_U8* string_data;
|
||||
RADDBGI_U64 string_data_size;
|
||||
RADDBGI_U32* string_offs;
|
||||
RADDBGI_U64 string_count;
|
||||
RADDBGI_U32* idx_run_data;
|
||||
RADDBGI_U32 idx_run_count;
|
||||
RDI_U8* string_data;
|
||||
RDI_U64 string_data_size;
|
||||
RDI_U32* string_offs;
|
||||
RDI_U64 string_count;
|
||||
RDI_U32* idx_run_data;
|
||||
RDI_U32 idx_run_count;
|
||||
|
||||
// directly readable by users
|
||||
// (any of these may be empty and null even in a successful parse)
|
||||
RADDBGI_TopLevelInfo* top_level_info;
|
||||
RDI_TopLevelInfo* top_level_info;
|
||||
|
||||
RADDBGI_BinarySection* binary_sections;
|
||||
RADDBGI_U64 binary_sections_count;
|
||||
RADDBGI_FilePathNode* file_paths;
|
||||
RADDBGI_U64 file_paths_count;
|
||||
RADDBGI_SourceFile* source_files;
|
||||
RADDBGI_U64 source_files_count;
|
||||
RADDBGI_Unit* units;
|
||||
RADDBGI_U64 units_count;
|
||||
RADDBGI_VMapEntry* unit_vmap;
|
||||
RADDBGI_U64 unit_vmap_count;
|
||||
RADDBGI_TypeNode* type_nodes;
|
||||
RADDBGI_U64 type_nodes_count;
|
||||
RADDBGI_UDT* udts;
|
||||
RADDBGI_U64 udts_count;
|
||||
RADDBGI_Member* members;
|
||||
RADDBGI_U64 members_count;
|
||||
RADDBGI_EnumMember* enum_members;
|
||||
RADDBGI_U64 enum_members_count;
|
||||
RADDBGI_GlobalVariable* global_variables;
|
||||
RADDBGI_U64 global_variables_count;
|
||||
RADDBGI_VMapEntry* global_vmap;
|
||||
RADDBGI_U64 global_vmap_count;
|
||||
RADDBGI_ThreadVariable* thread_variables;
|
||||
RADDBGI_U64 thread_variables_count;
|
||||
RADDBGI_Procedure* procedures;
|
||||
RADDBGI_U64 procedures_count;
|
||||
RADDBGI_Scope* scopes;
|
||||
RADDBGI_U64 scopes_count;
|
||||
RADDBGI_U64* scope_voffs;
|
||||
RADDBGI_U64 scope_voffs_count;
|
||||
RADDBGI_VMapEntry* scope_vmap;
|
||||
RADDBGI_U64 scope_vmap_count;
|
||||
RADDBGI_Local* locals;
|
||||
RADDBGI_U64 locals_count;
|
||||
RADDBGI_LocationBlock* location_blocks;
|
||||
RADDBGI_U64 location_blocks_count;
|
||||
RADDBGI_U8* location_data;
|
||||
RADDBGI_U64 location_data_size;
|
||||
RADDBGI_NameMap* name_maps;
|
||||
RADDBGI_U64 name_maps_count;
|
||||
RDI_BinarySection* binary_sections;
|
||||
RDI_U64 binary_sections_count;
|
||||
RDI_FilePathNode* file_paths;
|
||||
RDI_U64 file_paths_count;
|
||||
RDI_SourceFile* source_files;
|
||||
RDI_U64 source_files_count;
|
||||
RDI_Unit* units;
|
||||
RDI_U64 units_count;
|
||||
RDI_VMapEntry* unit_vmap;
|
||||
RDI_U64 unit_vmap_count;
|
||||
RDI_TypeNode* type_nodes;
|
||||
RDI_U64 type_nodes_count;
|
||||
RDI_UDT* udts;
|
||||
RDI_U64 udts_count;
|
||||
RDI_Member* members;
|
||||
RDI_U64 members_count;
|
||||
RDI_EnumMember* enum_members;
|
||||
RDI_U64 enum_members_count;
|
||||
RDI_GlobalVariable* global_variables;
|
||||
RDI_U64 global_variables_count;
|
||||
RDI_VMapEntry* global_vmap;
|
||||
RDI_U64 global_vmap_count;
|
||||
RDI_ThreadVariable* thread_variables;
|
||||
RDI_U64 thread_variables_count;
|
||||
RDI_Procedure* procedures;
|
||||
RDI_U64 procedures_count;
|
||||
RDI_Scope* scopes;
|
||||
RDI_U64 scopes_count;
|
||||
RDI_U64* scope_voffs;
|
||||
RDI_U64 scope_voffs_count;
|
||||
RDI_VMapEntry* scope_vmap;
|
||||
RDI_U64 scope_vmap_count;
|
||||
RDI_Local* locals;
|
||||
RDI_U64 locals_count;
|
||||
RDI_LocationBlock* location_blocks;
|
||||
RDI_U64 location_blocks_count;
|
||||
RDI_U8* location_data;
|
||||
RDI_U64 location_data_size;
|
||||
RDI_NameMap* name_maps;
|
||||
RDI_U64 name_maps_count;
|
||||
|
||||
// other helpers
|
||||
|
||||
RADDBGI_NameMap* name_maps_by_kind[RADDBGI_NameMapKind_COUNT];
|
||||
RDI_NameMap* name_maps_by_kind[RDI_NameMapKind_COUNT];
|
||||
|
||||
} RADDBGI_Parsed;
|
||||
} RDI_Parsed;
|
||||
|
||||
typedef enum{
|
||||
RADDBGI_ParseStatus_Good = 0,
|
||||
RADDBGI_ParseStatus_HeaderDoesNotMatch = 1,
|
||||
RADDBGI_ParseStatus_UnsupportedVersionNumber = 2,
|
||||
RADDBGI_ParseStatus_InvalidDataSecionLayout = 3,
|
||||
RADDBGI_ParseStatus_MissingStringDataSection = 4,
|
||||
RADDBGI_ParseStatus_MissingStringTableSection = 5,
|
||||
RADDBGI_ParseStatus_MissingIndexRunSection = 6,
|
||||
} RADDBGI_ParseStatus;
|
||||
RDI_ParseStatus_Good = 0,
|
||||
RDI_ParseStatus_HeaderDoesNotMatch = 1,
|
||||
RDI_ParseStatus_UnsupportedVersionNumber = 2,
|
||||
RDI_ParseStatus_InvalidDataSecionLayout = 3,
|
||||
RDI_ParseStatus_MissingStringDataSection = 4,
|
||||
RDI_ParseStatus_MissingStringTableSection = 5,
|
||||
RDI_ParseStatus_MissingIndexRunSection = 6,
|
||||
} RDI_ParseStatus;
|
||||
|
||||
typedef struct RADDBGI_ParsedLineInfo{
|
||||
typedef struct RDI_ParsedLineInfo{
|
||||
// NOTE: Mapping VOFF -> LINE_INFO
|
||||
//
|
||||
// * [ voff[i], voff[i + 1] ) forms the voff range
|
||||
// * for the line info at lines[i] (and cols[i] if i < col_count)
|
||||
|
||||
RADDBGI_U64* voffs; // [count + 1] sorted
|
||||
RADDBGI_Line* lines; // [count]
|
||||
RADDBGI_Column* cols; // [col_count]
|
||||
RADDBGI_U64 count;
|
||||
RADDBGI_U64 col_count;
|
||||
} RADDBGI_ParsedLineInfo;
|
||||
RDI_U64* voffs; // [count + 1] sorted
|
||||
RDI_Line* lines; // [count]
|
||||
RDI_Column* cols; // [col_count]
|
||||
RDI_U64 count;
|
||||
RDI_U64 col_count;
|
||||
} RDI_ParsedLineInfo;
|
||||
|
||||
typedef struct RADDBGI_ParsedLineMap{
|
||||
typedef struct RDI_ParsedLineMap{
|
||||
// NOTE: Mapping LINE_NUMBER -> VOFFs
|
||||
//
|
||||
// * nums[i] gives a line number
|
||||
@@ -109,111 +109,111 @@ typedef struct RADDBGI_ParsedLineMap{
|
||||
// * let k span over the range [ ranges[i], ranges[i + 1] )
|
||||
// * voffs[k] gives the associated voffs
|
||||
|
||||
RADDBGI_U32* nums; // [count] sorted
|
||||
RADDBGI_U32* ranges; // [count + 1]
|
||||
RADDBGI_U64* voffs; // [voff_count]
|
||||
RADDBGI_U64 count;
|
||||
RADDBGI_U64 voff_count;
|
||||
} RADDBGI_ParsedLineMap;
|
||||
RDI_U32* nums; // [count] sorted
|
||||
RDI_U32* ranges; // [count + 1]
|
||||
RDI_U64* voffs; // [voff_count]
|
||||
RDI_U64 count;
|
||||
RDI_U64 voff_count;
|
||||
} RDI_ParsedLineMap;
|
||||
|
||||
|
||||
typedef struct RADDBGI_ParsedNameMap{
|
||||
RADDBGI_NameMapBucket *buckets;
|
||||
RADDBGI_NameMapNode *nodes;
|
||||
RADDBGI_U64 bucket_count;
|
||||
RADDBGI_U64 node_count;
|
||||
} RADDBGI_ParsedNameMap;
|
||||
typedef struct RDI_ParsedNameMap{
|
||||
RDI_NameMapBucket *buckets;
|
||||
RDI_NameMapNode *nodes;
|
||||
RDI_U64 bucket_count;
|
||||
RDI_U64 node_count;
|
||||
} RDI_ParsedNameMap;
|
||||
|
||||
////////////////////////////////
|
||||
//~ Global Nils
|
||||
|
||||
#if !defined(RADDBGI_DISABLE_NILS)
|
||||
static RADDBGI_BinarySection raddbgi_binary_section_nil = {0};
|
||||
static RADDBGI_FilePathNode raddbgi_file_path_node_nil = {0};
|
||||
static RADDBGI_SourceFile raddbgi_source_file_nil = {0};
|
||||
static RADDBGI_Unit raddbgi_unit_nil = {0};
|
||||
static RADDBGI_VMapEntry raddbgi_vmap_entry_nil = {0};
|
||||
static RADDBGI_TypeNode raddbgi_type_node_nil = {0};
|
||||
static RADDBGI_UDT raddbgi_udt_nil = {0};
|
||||
static RADDBGI_Member raddbgi_member_nil = {0};
|
||||
static RADDBGI_EnumMember raddbgi_enum_member_nil = {0};
|
||||
static RADDBGI_GlobalVariable raddbgi_global_variable_nil = {0};
|
||||
static RADDBGI_ThreadVariable raddbgi_thread_variable_nil = {0};
|
||||
static RADDBGI_Procedure raddbgi_procedure_nil = {0};
|
||||
static RADDBGI_Scope raddbgi_scope_nil = {0};
|
||||
static RADDBGI_U64 raddbgi_voff_nil = 0;
|
||||
static RADDBGI_LocationBlock raddbgi_location_block_nil = {0};
|
||||
static RADDBGI_Local raddbgi_local_nil = {0};
|
||||
#if !defined(RDI_DISABLE_NILS)
|
||||
static RDI_BinarySection rdi_binary_section_nil = {0};
|
||||
static RDI_FilePathNode rdi_file_path_node_nil = {0};
|
||||
static RDI_SourceFile rdi_source_file_nil = {0};
|
||||
static RDI_Unit rdi_unit_nil = {0};
|
||||
static RDI_VMapEntry rdi_vmap_entry_nil = {0};
|
||||
static RDI_TypeNode rdi_type_node_nil = {0};
|
||||
static RDI_UDT rdi_udt_nil = {0};
|
||||
static RDI_Member rdi_member_nil = {0};
|
||||
static RDI_EnumMember rdi_enum_member_nil = {0};
|
||||
static RDI_GlobalVariable rdi_global_variable_nil = {0};
|
||||
static RDI_ThreadVariable rdi_thread_variable_nil = {0};
|
||||
static RDI_Procedure rdi_procedure_nil = {0};
|
||||
static RDI_Scope rdi_scope_nil = {0};
|
||||
static RDI_U64 rdi_voff_nil = 0;
|
||||
static RDI_LocationBlock rdi_location_block_nil = {0};
|
||||
static RDI_Local rdi_local_nil = {0};
|
||||
#endif
|
||||
|
||||
////////////////////////////////
|
||||
//~ RADDBG Parse API
|
||||
|
||||
RADDBGI_PROC RADDBGI_ParseStatus
|
||||
raddbgi_parse(RADDBGI_U8 *data, RADDBGI_U64 size, RADDBGI_Parsed *out);
|
||||
RDI_PROC RDI_ParseStatus
|
||||
rdi_parse(RDI_U8 *data, RDI_U64 size, RDI_Parsed *out);
|
||||
|
||||
RADDBGI_PROC RADDBGI_U8*
|
||||
raddbgi_string_from_idx(RADDBGI_Parsed *parsed, RADDBGI_U32 idx, RADDBGI_U64 *len_out);
|
||||
RDI_PROC RDI_U8*
|
||||
rdi_string_from_idx(RDI_Parsed *parsed, RDI_U32 idx, RDI_U64 *len_out);
|
||||
|
||||
RADDBGI_PROC RADDBGI_U32*
|
||||
raddbgi_idx_run_from_first_count(RADDBGI_Parsed *parsed, RADDBGI_U32 first, RADDBGI_U32 raw_count,
|
||||
RADDBGI_U32 *n_out);
|
||||
RDI_PROC RDI_U32*
|
||||
rdi_idx_run_from_first_count(RDI_Parsed *parsed, RDI_U32 first, RDI_U32 raw_count,
|
||||
RDI_U32 *n_out);
|
||||
|
||||
//- table lookups
|
||||
#define raddbgi_element_from_idx(parsed, name, idx) ((0 <= (idx) && (idx) < (parsed)->name##_count) ? &(parsed)->name[idx] : (parsed)->name ? &(parsed)->name[0] : 0)
|
||||
#define rdi_element_from_idx(parsed, name, idx) ((0 <= (idx) && (idx) < (parsed)->name##_count) ? &(parsed)->name[idx] : (parsed)->name ? &(parsed)->name[0] : 0)
|
||||
|
||||
//- line info
|
||||
RADDBGI_PROC void
|
||||
raddbgi_line_info_from_unit(RADDBGI_Parsed *p, RADDBGI_Unit *unit, RADDBGI_ParsedLineInfo *out);
|
||||
RDI_PROC void
|
||||
rdi_line_info_from_unit(RDI_Parsed *p, RDI_Unit *unit, RDI_ParsedLineInfo *out);
|
||||
|
||||
RADDBGI_PROC RADDBGI_U64
|
||||
raddbgi_line_info_idx_from_voff(RADDBGI_ParsedLineInfo *line_info, RADDBGI_U64 voff);
|
||||
RDI_PROC RDI_U64
|
||||
rdi_line_info_idx_from_voff(RDI_ParsedLineInfo *line_info, RDI_U64 voff);
|
||||
|
||||
RADDBGI_PROC void
|
||||
raddbgi_line_map_from_source_file(RADDBGI_Parsed *p, RADDBGI_SourceFile *srcfile,
|
||||
RADDBGI_ParsedLineMap *out);
|
||||
RDI_PROC void
|
||||
rdi_line_map_from_source_file(RDI_Parsed *p, RDI_SourceFile *srcfile,
|
||||
RDI_ParsedLineMap *out);
|
||||
|
||||
RADDBGI_PROC RADDBGI_U64*
|
||||
raddbgi_line_voffs_from_num(RADDBGI_ParsedLineMap *map, RADDBGI_U32 linenum, RADDBGI_U32 *n_out);
|
||||
RDI_PROC RDI_U64*
|
||||
rdi_line_voffs_from_num(RDI_ParsedLineMap *map, RDI_U32 linenum, RDI_U32 *n_out);
|
||||
|
||||
|
||||
//- vmaps
|
||||
RADDBGI_PROC RADDBGI_U64
|
||||
raddbgi_vmap_idx_from_voff(RADDBGI_VMapEntry *vmap, RADDBGI_U32 vmap_count, RADDBGI_U64 voff);
|
||||
RDI_PROC RDI_U64
|
||||
rdi_vmap_idx_from_voff(RDI_VMapEntry *vmap, RDI_U32 vmap_count, RDI_U64 voff);
|
||||
|
||||
|
||||
//- name maps
|
||||
RADDBGI_PROC RADDBGI_NameMap*
|
||||
raddbgi_name_map_from_kind(RADDBGI_Parsed *p, RADDBGI_NameMapKind kind);
|
||||
RDI_PROC RDI_NameMap*
|
||||
rdi_name_map_from_kind(RDI_Parsed *p, RDI_NameMapKind kind);
|
||||
|
||||
RADDBGI_PROC void
|
||||
raddbgi_name_map_parse(RADDBGI_Parsed* p, RADDBGI_NameMap *mapptr, RADDBGI_ParsedNameMap *out);
|
||||
RDI_PROC void
|
||||
rdi_name_map_parse(RDI_Parsed* p, RDI_NameMap *mapptr, RDI_ParsedNameMap *out);
|
||||
|
||||
RADDBGI_PROC RADDBGI_NameMapNode*
|
||||
raddbgi_name_map_lookup(RADDBGI_Parsed *p, RADDBGI_ParsedNameMap *map,
|
||||
RADDBGI_U8 *str, RADDBGI_U64 len);
|
||||
RDI_PROC RDI_NameMapNode*
|
||||
rdi_name_map_lookup(RDI_Parsed *p, RDI_ParsedNameMap *map,
|
||||
RDI_U8 *str, RDI_U64 len);
|
||||
|
||||
RADDBGI_PROC RADDBGI_U32*
|
||||
raddbgi_matches_from_map_node(RADDBGI_Parsed *p, RADDBGI_NameMapNode *node, RADDBGI_U32 *n_out);
|
||||
RDI_PROC RDI_U32*
|
||||
rdi_matches_from_map_node(RDI_Parsed *p, RDI_NameMapNode *node, RDI_U32 *n_out);
|
||||
|
||||
|
||||
//- common helpers
|
||||
RADDBGI_PROC RADDBGI_U64
|
||||
raddbgi_first_voff_from_proc(RADDBGI_Parsed *p, RADDBGI_U32 proc_id);
|
||||
RDI_PROC RDI_U64
|
||||
rdi_first_voff_from_proc(RDI_Parsed *p, RDI_U32 proc_id);
|
||||
|
||||
|
||||
|
||||
////////////////////////////////
|
||||
//~ RADDBG Parsing Helpers
|
||||
|
||||
#define raddbgi_parse__extract_primary(p,outptr,outn,pritag) \
|
||||
#define rdi_parse__extract_primary(p,outptr,outn,pritag) \
|
||||
( (*(void**)&(outptr)) = \
|
||||
raddbgi_data_from_dsec((p),(p)->dsec_idx[pritag],sizeof(*(outptr)),(pritag),(outn)) )
|
||||
rdi_data_from_dsec((p),(p)->dsec_idx[pritag],sizeof(*(outptr)),(pritag),(outn)) )
|
||||
|
||||
RADDBGI_PROC void*
|
||||
raddbgi_data_from_dsec(RADDBGI_Parsed *p, RADDBGI_U32 idx, RADDBGI_U32 item_size,
|
||||
RADDBGI_DataSectionTag expected_tag, RADDBGI_U64 *n_out);
|
||||
RDI_PROC void*
|
||||
rdi_data_from_dsec(RDI_Parsed *p, RDI_U32 idx, RDI_U32 item_size,
|
||||
RDI_DataSectionTag expected_tag, RDI_U64 *n_out);
|
||||
|
||||
#define raddbgi_parse__min(a,b) (((a)<(b))?(a):(b))
|
||||
#define rdi_parse__min(a,b) (((a)<(b))?(a):(b))
|
||||
|
||||
#endif // RADDBGI_PARSE_H
|
||||
#endif // RDI_PARSE_H
|
||||
|
||||
Reference in New Issue
Block a user