ed/raddebugger
1
0
Fork 0
mirror of https://github.com/Ed94/raddebugger.git synced 2026-07-15 05:51:26 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
6cdce22284b69691a5718c20358db631ec95ffa4
raddebugger/src/lib_rdi_make/rdi_make.c
T

2079 lines
68 KiB
C
Raw Blame History

// Copyright (c) Epic Games Tools
// Licensed under the MIT license (https://opensource.org/license/mit/)
////////////////////////////////
//~ rjf: API Implementation Helper Macros
#define RDIM_IdxedChunkListPush(arena, list, chunk_type, element_type, cap_value, result, ...) \
element_type *result = 0;\
do\
{\
chunk_type *n = list->last;\
if(n == 0 || n->count >= n->cap)\
{\
n = rdim_push_array(arena, chunk_type, 1);\
n->cap = cap_value;\
n->base_idx = list->total_count;\
__VA_ARGS__;\
n->v = rdim_push_array_no_zero(arena, element_type, n->cap);\
RDIM_SLLQueuePush(list->first, list->last, n);\
list->chunk_count += 1;\
}\
result = &n->v[n->count];\
result->chunk = n;\
n->count += 1;\
list->total_count += 1;\
}while(0)
#define RDIM_IdxedChunkListElementGetIdx(ptr, result) \
RDI_U64 idx = 0;\
if(ptr != 0 && ptr->chunk != 0)\
{\
idx = ptr->chunk->base_idx + (ptr - ptr->chunk->v) + 1;\
}
#define RDIM_IdxedChunkListConcatInPlace(chunk_type, dst, to_push, ...) \
for(chunk_type *n = to_push->first; n != 0; n = n->next)\
{\
n->base_idx += dst->total_count;\
}\
if(dst->last != 0 && to_push->first != 0)\
{\
dst->last->next = to_push->first;\
dst->last = to_push->last;\
dst->chunk_count += to_push->chunk_count;\
dst->total_count += to_push->total_count;\
__VA_ARGS__;\
}\
else if(dst->first == 0)\
{\
rdim_memcpy_struct(dst, to_push);\
}\
rdim_memzero_struct(to_push);
////////////////////////////////
//~ rjf: Basic Helpers
//- rjf: memory set
#if !defined(RDIM_MEMSET_OVERRIDE)
RDI_PROC void *
rdim_memset_fallback(void *dst, RDI_U8 c, RDI_U64 size)
{
for(RDI_U64 idx = 0; idx < size; idx += 1)
{
((RDI_U8 *)dst)[idx] = c;
}
return dst;
}
#endif
#if !defined(RDIM_MEMCPY_OVERRIDE)
RDI_PROC void *
rdim_memcpy_fallback(void *dst, void *src, RDI_U64 size)
{
for(RDI_U64 idx = 0; idx < size; idx += 1)
{
((RDI_U8 *)dst)[idx] = ((RDI_U8 *)src)[idx];
}
return dst;
}
#endif
//- rjf: arenas
#if !defined (RDIM_ARENA_OVERRIDE)
RDI_PROC RDIM_Arena *
rdim_arena_alloc_fallback(void)
{
RDIM_Arena *arena = 0;
// TODO(rjf)
return arena;
}
RDI_PROC void
rdim_arena_release_fallback(RDIM_Arena *arena)
{
// TODO(rjf)
}
RDI_PROC RDI_U64
rdim_arena_pos_fallback(RDIM_Arena *arena)
{
// TODO(rjf)
return 0;
}
RDI_PROC void *
rdim_arena_push_fallback(RDIM_Arena *arena, RDI_U64 size, RDI_U64 align, RDI_U32 zero)
{
// TODO(rjf)
return 0;
}
RDI_PROC void
rdim_arena_pop_to_fallback(RDIM_Arena *arena, RDI_U64 pos)
{
// TODO(rjf)
}
#endif
//- rjf: thread-local scratch arenas
#if !defined (RDIM_SCRATCH_OVERRIDE)
static RDIM_THREAD_LOCAL RDIM_Arena *rdim_thread_scratches[2];
RDI_PROC RDIM_Temp
rdim_scratch_begin_fallback(RDIM_Arena **conflicts, RDI_U64 conflicts_count)
{
if(rdim_thread_scratches[0] == 0)
{
rdim_thread_scratches[0] = rdim_arena_alloc();
rdim_thread_scratches[1] = rdim_arena_alloc();
}
RDIM_Arena *arena = 0;
for(RDI_U64 scratch_idx = 0;
scratch_idx < sizeof(rdim_thread_scratches)/sizeof(rdim_thread_scratches[0]);
scratch_idx += 1)
{
RDI_S32 scratch_conflicts = 0;
for(RDI_U64 conflict_idx = 0; conflict_idx < conflicts_count; conflict_idx += 1)
{
if(conflicts[conflict_idx] == rdim_thread_scratches[scratch_idx])
{
scratch_conflicts = 1;
break;
}
}
if(!scratch_conflicts)
{
arena = rdim_thread_scratches[scratch_idx];
}
}
RDIM_Temp temp;
temp.arena = arena;
temp.pos = rdim_arena_pos(arena);
return temp;
}
RDI_PROC void
rdim_scratch_end_fallback(RDIM_Temp temp)
{
rdim_arena_pop_to(temp.arena, temp.pos);
}
#endif
//- rjf: strings
RDI_PROC RDIM_String8
rdim_str8(RDI_U8 *str, RDI_U64 size)
{
RDIM_String8 result;
result.RDIM_String8_BaseMember = str;
result.RDIM_String8_SizeMember = size;
return result;
}
RDI_PROC RDIM_String8
rdim_str8_copy(RDIM_Arena *arena, RDIM_String8 src)
{
RDIM_String8 dst;
dst.RDIM_String8_SizeMember = src.RDIM_String8_SizeMember;
dst.RDIM_String8_BaseMember = rdim_push_array_no_zero(arena, RDI_U8, dst.RDIM_String8_SizeMember+1);
rdim_memcpy(dst.RDIM_String8_BaseMember, src.RDIM_String8_BaseMember, src.RDIM_String8_SizeMember);
dst.RDIM_String8_BaseMember[dst.RDIM_String8_SizeMember] = 0;
return dst;
}
RDI_PROC RDIM_String8
rdim_str8f(RDIM_Arena *arena, char *fmt, ...)
{
va_list args;
va_start(args, fmt);
RDIM_String8 result = rdim_str8fv(arena, fmt, args);
va_end(args);
return(result);
}
RDI_PROC RDIM_String8
rdim_str8fv(RDIM_Arena *arena, char *fmt, va_list args)
{
va_list args2;
va_copy(args2, args);
RDI_U32 needed_bytes = rdim_vsnprintf(0, 0, fmt, args) + 1;
RDIM_String8 result = {0};
result.RDIM_String8_BaseMember = rdim_push_array_no_zero(arena, RDI_U8, needed_bytes);
result.RDIM_String8_SizeMember = rdim_vsnprintf((char*)result.str, needed_bytes, fmt, args2);
result.RDIM_String8_BaseMember[result.RDIM_String8_SizeMember] = 0;
va_end(args2);
return(result);
}
RDI_PROC RDI_S32
rdim_str8_match(RDIM_String8 a, RDIM_String8 b, RDIM_StringMatchFlags flags)
{
RDI_S32 result = 0;
if(a.RDIM_String8_SizeMember == b.RDIM_String8_SizeMember)
{
RDI_S32 case_insensitive = (flags & RDIM_StringMatchFlag_CaseInsensitive);
RDI_U64 size = a.RDIM_String8_SizeMember;
result = 1;
for(RDI_U64 idx = 0; idx < size; idx += 1)
{
RDI_U8 at = a.RDIM_String8_BaseMember[idx];
RDI_U8 bt = b.RDIM_String8_BaseMember[idx];
if(case_insensitive)
{
at = ('a' <= at && at <= 'z') ? at-('a'-'A') : at;
bt = ('a' <= bt && bt <= 'z') ? bt-('a'-'A') : bt;
}
if(at != bt)
{
result = 0;
break;
}
}
}
return result;
}
RDI_PROC RDIM_String8
rdim_lower_from_str8(RDIM_Arena *arena, RDIM_String8 string)
{
RDIM_String8 result = rdim_str8_copy(arena, string);
for(RDI_U64 idx = 0; idx < result.RDIM_String8_SizeMember; idx += 1)
{
RDI_U8 byte = result.RDIM_String8_BaseMember[idx];
if('A' <= byte && byte <= 'Z')
{
result.RDIM_String8_BaseMember[idx] += ('a' - 'A');
}
}
return result;
}
//- rjf: string lists
RDI_PROC void
rdim_str8_list_push(RDIM_Arena *arena, RDIM_String8List *list, RDIM_String8 string)
{
RDIM_String8Node *n = rdim_push_array(arena, RDIM_String8Node, 1);
n->RDIM_String8Node_StringMember = string;
RDIM_SLLQueuePush_N(list->RDIM_String8List_FirstMember, list->RDIM_String8List_LastMember, n, RDIM_String8Node_NextPtrMember);
list->RDIM_String8List_NodeCountMember += 1;
list->RDIM_String8List_TotalSizeMember += string.RDIM_String8_SizeMember;
}
RDI_PROC void
rdim_str8_list_push_front(RDIM_Arena *arena, RDIM_String8List *list, RDIM_String8 string)
{
RDIM_String8Node *n = rdim_push_array(arena, RDIM_String8Node, 1);
n->RDIM_String8Node_StringMember = string;
RDIM_SLLQueuePushFront_N(list->RDIM_String8List_FirstMember, list->RDIM_String8List_LastMember, n, RDIM_String8Node_NextPtrMember);
list->RDIM_String8List_NodeCountMember += 1;
list->RDIM_String8List_TotalSizeMember += string.RDIM_String8_SizeMember;
}
RDI_PROC void
rdim_str8_list_push_align(RDIM_Arena *arena, RDIM_String8List *list, RDI_U64 align)
{
RDI_U64 total_size_pre_align = list->total_size;
RDI_U64 total_size_post_align = (total_size_pre_align + (align-1))&(~(align-1));
RDI_U64 needed_size = total_size_post_align - total_size_pre_align;
if(needed_size != 0)
{
RDI_U8 *padding = rdim_push_array(arena, RDI_U8, needed_size);
rdim_str8_list_push(arena, list, rdim_str8(padding, needed_size));
}
}
RDI_PROC RDIM_String8
rdim_str8_list_join(RDIM_Arena *arena, RDIM_String8List *list, RDIM_String8 sep)
{
RDIM_String8 result;
rdim_memzero_struct(&result);
RDI_U64 sep_count = (list->RDIM_String8List_NodeCountMember > 1) ? (list->RDIM_String8List_NodeCountMember-1) : 0;
result.RDIM_String8_SizeMember = list->RDIM_String8List_TotalSizeMember+sep_count*sep.RDIM_String8_SizeMember;
result.RDIM_String8_BaseMember = rdim_push_array_no_zero(arena, RDI_U8, result.RDIM_String8_SizeMember+1);
RDI_U64 off = 0;
for(RDIM_String8Node *node = list->RDIM_String8List_FirstMember;
node != 0;
node = node->RDIM_String8Node_NextPtrMember)
{
rdim_memcpy((RDI_U8*)result.RDIM_String8_BaseMember+off,
node->RDIM_String8Node_StringMember.RDIM_String8_BaseMember,
node->RDIM_String8Node_StringMember.RDIM_String8_SizeMember);
off += node->RDIM_String8Node_StringMember.RDIM_String8_SizeMember;
if(sep.RDIM_String8_SizeMember != 0 && node->RDIM_String8Node_NextPtrMember != 0)
{
rdim_memcpy((RDI_U8*)result.RDIM_String8_BaseMember+off,
sep.RDIM_String8_BaseMember,
sep.RDIM_String8_SizeMember);
off += sep.RDIM_String8_SizeMember;
}
}
result.RDIM_String8_BaseMember[off] = 0;
return result;
}
//- rjf: sortable range sorting
RDI_PROC RSFORCEINLINE int
rdim_sort_key_is_before(void *l, void *r)
{
return ((RDIM_SortKey *)l)->key < ((RDIM_SortKey *)r)->key;
}
RDI_PROC RDIM_SortKey *
rdim_sort_key_array(RDIM_Arena *arena, RDIM_SortKey *keys, RDI_U64 count)
{
// This sort is designed to take advantage of lots of pre-existing sorted ranges.
// Most line info is already sorted or close to already sorted.
// Similarly most vmap data has lots of pre-sorted ranges. etc. etc.
// Also - this sort should be a "stable" sort. In the use case of sorting vmap
// ranges, we want to be able to rely on order, so it needs to be preserved here.
RDIM_Temp scratch = rdim_scratch_begin(&arena, 1);
RDIM_SortKey *result = 0;
if(count <= 1)
{
result = keys;
}
else
{
RDIM_OrderedRange *ranges_first = 0;
RDIM_OrderedRange *ranges_last = 0;
RDI_U64 range_count = 0;
{
RDI_U64 pos = 0;
for(;pos < count;)
{
// identify ordered range
RDI_U64 first = pos;
RDI_U64 opl = pos + 1;
for(; opl < count && keys[opl - 1].key <= keys[opl].key; opl += 1);
// generate an ordered range node
RDIM_OrderedRange *new_range = rdim_push_array(rdim_temp_arena(scratch), RDIM_OrderedRange, 1);
RDIM_SLLQueuePush(ranges_first, ranges_last, new_range);
range_count += 1;
new_range->first = first;
new_range->opl = opl;
// update pos
pos = opl;
}
}
if(range_count == 1)
{
result = keys;
}
else
{
RDIM_SortKey *keys_swap = rdim_push_array_no_zero(arena, RDIM_SortKey, count);
RDIM_SortKey *src = keys;
RDIM_SortKey *dst = keys_swap;
RDIM_OrderedRange *src_ranges = ranges_first;
RDIM_OrderedRange *dst_ranges = 0;
RDIM_OrderedRange *dst_ranges_last = 0;
for(;;)
{
// begin a pass
for(;;)
{
// end pass when out of ranges
if(src_ranges == 0)
{
break;
}
// get first range
RDIM_OrderedRange *range1 = src_ranges;
RDIM_SLLStackPop(src_ranges);
// if this range is the whole array, we are done
if(range1->first == 0 && range1->opl == count)
{
result = src;
goto sort_done;
}
// if there is not a second range, save this range for next time and end this pass
if(src_ranges == 0)
{
RDI_U64 first = range1->first;
rdim_memcpy(dst + first, src + first, sizeof(*src)*(range1->opl - first));
RDIM_SLLQueuePush(dst_ranges, dst_ranges_last, range1);
break;
}
// get second range
RDIM_OrderedRange *range2 = src_ranges;
RDIM_SLLStackPop(src_ranges);
#if 0
rdim_assert(range1->opl == range2->first);
#endif
// merge these ranges
RDI_U64 jd = range1->first;
RDI_U64 j1 = range1->first;
RDI_U64 j1_opl = range1->opl;
RDI_U64 j2 = range2->first;
RDI_U64 j2_opl = range2->opl;
for(;;)
{
if(src[j1].key <= src[j2].key)
{
rdim_memcpy(dst + jd, src + j1, sizeof(*src));
j1 += 1;
jd += 1;
if(j1 >= j1_opl)
{
break;
}
}
else
{
rdim_memcpy(dst + jd, src + j2, sizeof(*src));
j2 += 1;
jd += 1;
if(j2 >= j2_opl)
{
break;
}
}
}
if(j1 < j1_opl)
{
rdim_memcpy(dst + jd, src + j1, sizeof(*src)*(j1_opl - j1));
}
else
{
rdim_memcpy(dst + jd, src + j2, sizeof(*src)*(j2_opl - j2));
}
// save this as one range
range1->opl = range2->opl;
SLLQueuePush(dst_ranges, dst_ranges_last, range1);
}
// end pass by swapping buffers and range nodes
{
RDIM_SortKey *temp = src;
src = dst;
dst = temp;
}
src_ranges = dst_ranges;
dst_ranges = 0;
dst_ranges_last = 0;
}
}
}
sort_done:;
#if 0
// assert sortedness
for(RDI_U64 i = 1; i < count; i += 1)
{
rdim_assert(result[i - 1].key <= result[i].key);
}
#endif
rdim_scratch_end(scratch);
return result;
}
//- rjf: rng1u64 list
RDI_PROC void
rdim_rng1u64_list_push(RDIM_Arena *arena, RDIM_Rng1U64List *list, RDIM_Rng1U64 r)
{
RDIM_Rng1U64Node *n = rdim_push_array(arena, RDIM_Rng1U64Node, 1);
n->v = r;
RDIM_SLLQueuePush(list->first, list->last, n);
list->count += 1;
if(list->count == 1 || r.min < list->min)
{
list->min = r.min;
}
}
RDI_PROC void
rdim_rng1u64_chunk_list_push(RDIM_Arena *arena, RDIM_Rng1U64ChunkList *list, RDI_U64 chunk_cap, RDIM_Rng1U64 r)
{
RDIM_Rng1U64ChunkNode *n = list->last;
if(n == 0 || n->count >= n->cap)
{
n = rdim_push_array(arena, RDIM_Rng1U64ChunkNode, 1);
RDIM_SLLQueuePush(list->first, list->last, n);
n->cap = chunk_cap;
n->v = rdim_push_array_no_zero(arena, RDIM_Rng1U64, n->cap);
list->chunk_count += 1;
}
n->v[n->count] = r;
n->count += 1;
list->total_count += 1;
if(list->total_count == 1 || r.min < list->min)
{
list->min = r.min;
}
}
////////////////////////////////
//~ rjf: [Building] Data Model
RDI_PROC RDI_TypeKind
rdim_short_type_kind_from_data_model(RDIM_DataModel data_model)
{
RDI_TypeKind result = RDI_TypeKind_NULL;
switch((RDIM_DataModelEnum)data_model)
{
case RDIM_DataModel_Null:{}break;
case RDIM_DataModel_ILP32 :{result = RDI_TypeKind_S16;}break;
case RDIM_DataModel_LLP64 :{result = RDI_TypeKind_S16;}break;
case RDIM_DataModel_LP64 :{result = RDI_TypeKind_S16;}break;
case RDIM_DataModel_ILP64 :{result = RDI_TypeKind_S16;}break;
case RDIM_DataModel_SILP64:{result = RDI_TypeKind_S64;}break;
}
return result;
}
RDI_PROC RDI_TypeKind
rdim_unsigned_short_type_kind_from_data_model(RDIM_DataModel data_model)
{
RDI_TypeKind result = RDI_TypeKind_NULL;
switch((RDIM_DataModelEnum)data_model)
{
case RDIM_DataModel_Null:{}break;
case RDIM_DataModel_ILP32 :{result = RDI_TypeKind_U16;}break;
case RDIM_DataModel_LLP64 :{result = RDI_TypeKind_U16;}break;
case RDIM_DataModel_LP64 :{result = RDI_TypeKind_U16;}break;
case RDIM_DataModel_ILP64 :{result = RDI_TypeKind_U16;}break;
case RDIM_DataModel_SILP64:{result = RDI_TypeKind_U64;}break;
}
return result;
}
RDI_PROC RDI_TypeKind
rdim_int_type_from_data_model(RDIM_DataModel data_model)
{
RDI_TypeKind result = RDI_TypeKind_NULL;
switch((RDIM_DataModelEnum)data_model)
{
case RDIM_DataModel_Null:{}break;
case RDIM_DataModel_ILP32 :{result = RDI_TypeKind_S32;}break;
case RDIM_DataModel_LLP64 :{result = RDI_TypeKind_S32;}break;
case RDIM_DataModel_LP64 :{result = RDI_TypeKind_S32;}break;
case RDIM_DataModel_ILP64 :{result = RDI_TypeKind_S64;}break;
case RDIM_DataModel_SILP64:{result = RDI_TypeKind_S64;}break;
}
return result;
}
RDI_PROC RDI_TypeKind
rdim_unsigned_int_type_from_data_model(RDIM_DataModel data_model)
{
RDI_TypeKind result = RDI_TypeKind_NULL;
switch((RDIM_DataModelEnum)data_model)
{
case RDIM_DataModel_Null:{}break;
case RDIM_DataModel_ILP32 :{result = RDI_TypeKind_U32;}break;
case RDIM_DataModel_LLP64 :{result = RDI_TypeKind_U32;}break;
case RDIM_DataModel_LP64 :{result = RDI_TypeKind_U32;}break;
case RDIM_DataModel_ILP64 :{result = RDI_TypeKind_U64;}break;
case RDIM_DataModel_SILP64:{result = RDI_TypeKind_U64;}break;
}
return result;
}
RDI_PROC RDI_TypeKind
rdim_long_type_kind_from_data_model(RDIM_DataModel data_model)
{
RDI_TypeKind result = RDI_TypeKind_NULL;
switch((RDIM_DataModelEnum)data_model)
{
case RDIM_DataModel_Null:{}break;
case RDIM_DataModel_ILP32 :{result = RDI_TypeKind_S32;}break;
case RDIM_DataModel_LLP64 :{result = RDI_TypeKind_S32;}break;
case RDIM_DataModel_LP64 :{result = RDI_TypeKind_S64;}break;
case RDIM_DataModel_ILP64 :{result = RDI_TypeKind_S64;}break;
case RDIM_DataModel_SILP64:{result = RDI_TypeKind_S64;}break;
}
return result;
}
RDI_PROC RDI_TypeKind
rdim_unsigned_long_type_kind_from_data_model(RDIM_DataModel data_model)
{
RDI_TypeKind result = RDI_TypeKind_NULL;
switch((RDIM_DataModelEnum)data_model)
{
case RDIM_DataModel_Null:{}break;
case RDIM_DataModel_ILP32 :{result = RDI_TypeKind_U32;}break;
case RDIM_DataModel_LLP64 :{result = RDI_TypeKind_U32;}break;
case RDIM_DataModel_LP64 :{result = RDI_TypeKind_U64;}break;
case RDIM_DataModel_ILP64 :{result = RDI_TypeKind_U64;}break;
case RDIM_DataModel_SILP64:{result = RDI_TypeKind_U64;}break;
}
return result;
}
RDI_PROC RDI_TypeKind
rdim_long_long_type_kind_from_data_model(RDIM_DataModel data_model)
{
RDI_TypeKind result = RDI_TypeKind_NULL;
switch((RDIM_DataModelEnum)data_model)
{
case RDIM_DataModel_Null:{}break;
case RDIM_DataModel_ILP32 :{result = RDI_TypeKind_S64;}break;
case RDIM_DataModel_LLP64 :{result = RDI_TypeKind_S64;}break;
case RDIM_DataModel_LP64 :{result = RDI_TypeKind_S64;}break;
case RDIM_DataModel_ILP64 :{result = RDI_TypeKind_S64;}break;
case RDIM_DataModel_SILP64:{result = RDI_TypeKind_S64;}break;
}
return result;
}
RDI_PROC RDI_TypeKind
rdim_unsigned_long_long_type_kind_from_data_model(RDIM_DataModel data_model)
{
RDI_TypeKind result = RDI_TypeKind_NULL;
switch((RDIM_DataModelEnum)data_model)
{
case RDIM_DataModel_Null:{}break;
case RDIM_DataModel_ILP32 :{result = RDI_TypeKind_U64;}break;
case RDIM_DataModel_LLP64 :{result = RDI_TypeKind_U64;}break;
case RDIM_DataModel_LP64 :{result = RDI_TypeKind_U64;}break;
case RDIM_DataModel_ILP64 :{result = RDI_TypeKind_U64;}break;
case RDIM_DataModel_SILP64:{result = RDI_TypeKind_U64;}break;
}
return result;
}
RDI_PROC RDI_TypeKind
rdim_pointer_size_t_type_kind_from_data_model(RDIM_DataModel data_model)
{
RDI_TypeKind result = RDI_TypeKind_NULL;
switch((RDIM_DataModelEnum)data_model)
{
case RDIM_DataModel_Null:{}break;
case RDIM_DataModel_ILP32 :{result = RDI_TypeKind_U32;}break;
case RDIM_DataModel_LLP64 :{result = RDI_TypeKind_U64;}break;
case RDIM_DataModel_LP64 :{result = RDI_TypeKind_U64;}break;
case RDIM_DataModel_ILP64 :{result = RDI_TypeKind_U64;}break;
case RDIM_DataModel_SILP64:{result = RDI_TypeKind_U64;}break;
}
return result;
}
////////////////////////////////
//~ rjf: [Building] Binary Section List Building
RDI_PROC RDIM_BinarySection *
rdim_binary_section_list_push(RDIM_Arena *arena, RDIM_BinarySectionList *list)
{
RDIM_BinarySectionNode *n = rdim_push_array(arena, RDIM_BinarySectionNode, 1);
RDIM_SLLQueuePush(list->first, list->last, n);
list->count += 1;
RDIM_BinarySection *result = &n->v;
return result;
}
////////////////////////////////
//~ rjf: [Building] Source File Info Building
RDI_PROC RDIM_SrcFile *
rdim_src_file_chunk_list_push(RDIM_Arena *arena, RDIM_SrcFileChunkList *list, RDI_U64 cap)
{
RDIM_IdxedChunkListPush(arena, list, RDIM_SrcFileChunkNode, RDIM_SrcFile, cap, result);
return result;
}
RDI_PROC RDI_U64
rdim_idx_from_src_file(RDIM_SrcFile *src_file)
{
RDIM_IdxedChunkListElementGetIdx(src_file, idx);
return idx;
}
RDI_PROC void
rdim_src_file_chunk_list_concat_in_place(RDIM_SrcFileChunkList *dst, RDIM_SrcFileChunkList *to_push)
{
RDIM_IdxedChunkListConcatInPlace(RDIM_SrcFileChunkNode, dst, to_push,
dst->source_line_map_count += to_push->source_line_map_count,
dst->total_line_count += to_push->total_line_count);
}
RDI_PROC void
rdim_src_file_push_line_sequence(RDIM_Arena *arena, RDIM_SrcFileChunkList *src_files, RDIM_SrcFile *src_file, RDIM_LineSequence *seq)
{
if(src_file->first_line_map_fragment == 0)
{
src_files->source_line_map_count += 1;
}
RDIM_SrcFileLineMapFragment *fragment = rdim_push_array(arena, RDIM_SrcFileLineMapFragment, 1);
fragment->seq = seq;
RDIM_SLLQueuePush(src_file->first_line_map_fragment, src_file->last_line_map_fragment, fragment);
src_file->total_line_count += seq->line_count;
src_files->total_line_count += seq->line_count;
}
////////////////////////////////
//~ rjf: [Building] Line Info Building
RDI_PROC RDIM_LineTable *
rdim_line_table_chunk_list_push(RDIM_Arena *arena, RDIM_LineTableChunkList *list, RDI_U64 cap)
{
RDIM_IdxedChunkListPush(arena, list, RDIM_LineTableChunkNode, RDIM_LineTable, cap, result);
return result;
}
RDI_PROC RDI_U64
rdim_idx_from_line_table(RDIM_LineTable *line_table)
{
RDIM_IdxedChunkListElementGetIdx(line_table, idx);
return idx;
}
RDI_PROC void
rdim_line_table_chunk_list_concat_in_place(RDIM_LineTableChunkList *dst, RDIM_LineTableChunkList *to_push)
{
RDIM_IdxedChunkListConcatInPlace(RDIM_LineTableChunkNode, dst, to_push,
dst->total_seq_count += to_push->total_seq_count,
dst->total_line_count += to_push->total_line_count,
dst->total_col_count += to_push->total_col_count);
}
RDI_PROC RDIM_LineSequence *
rdim_line_table_push_sequence(RDIM_Arena *arena, RDIM_LineTableChunkList *line_tables, RDIM_LineTable *line_table, RDIM_SrcFile *src_file, RDI_U64 *voffs, RDI_U32 *line_nums, RDI_U16 *col_nums, RDI_U64 line_count)
{
RDIM_LineSequenceNode *n = push_array(arena, RDIM_LineSequenceNode, 1);
n->v.src_file = src_file;
n->v.voffs = voffs;
n->v.line_nums = line_nums;
n->v.col_nums = col_nums;
n->v.line_count = line_count;
SLLQueuePush(line_table->first_seq, line_table->last_seq, n);
line_table->seq_count += 1;
line_table->line_count += line_count;
line_table->col_count += line_count*2*(col_nums != 0);
line_tables->total_seq_count += 1;
line_tables->total_line_count += line_count;
line_tables->total_col_count += line_count*2*(col_nums != 0);
return &n->v;
}
////////////////////////////////
//~ rjf: [Building] Unit List Building
RDI_PROC RDIM_Unit *
rdim_unit_chunk_list_push(RDIM_Arena *arena, RDIM_UnitChunkList *list, RDI_U64 cap)
{
RDIM_IdxedChunkListPush(arena, list, RDIM_UnitChunkNode, RDIM_Unit, cap, result);
return result;
}
RDI_PROC RDI_U64
rdim_idx_from_unit(RDIM_Unit *unit)
{
RDIM_IdxedChunkListElementGetIdx(unit, idx);
return idx;
}
RDI_PROC void
rdim_unit_chunk_list_concat_in_place(RDIM_UnitChunkList *dst, RDIM_UnitChunkList *to_push)
{
RDIM_IdxedChunkListConcatInPlace(RDIM_UnitChunkNode, dst, to_push);
}
////////////////////////////////
//~ rjf: [Building] Type Info Building
//- rjf: type nodes
RDI_PROC RDIM_Type **
rdim_array_from_type_list(RDIM_Arena *arena, RDIM_TypeList list)
{
RDIM_Type **arr = push_array(arena, RDIM_Type *, list.count);
U64 i = 0;
for(RDIM_TypeNode *n = list.first; n != 0; n = n->next, ++i)
{
arr[i] = n->v;
}
return arr;
}
RDI_PROC RDIM_TypeNode *
rdim_type_list_push(RDIM_Arena *arena, RDIM_TypeList *list, RDIM_Type *v)
{
RDIM_TypeNode *n = push_array(arena, RDIM_TypeNode, 1);
n->v = v;
SLLQueuePush(list->first, list->last, n);
list->count += 1;
return n;
}
RDI_PROC RDIM_Type *
rdim_type_chunk_list_push(RDIM_Arena *arena, RDIM_TypeChunkList *list, RDI_U64 cap)
{
RDIM_IdxedChunkListPush(arena, list, RDIM_TypeChunkNode, RDIM_Type, cap, result);
return result;
}
RDI_PROC RDI_U64
rdim_idx_from_type(RDIM_Type *type)
{
RDIM_IdxedChunkListElementGetIdx(type, idx);
return idx;
}
RDI_PROC void
rdim_type_chunk_list_concat_in_place(RDIM_TypeChunkList *dst, RDIM_TypeChunkList *to_push)
{
RDIM_IdxedChunkListConcatInPlace(RDIM_TypeChunkNode, dst, to_push);
}
//- rjf: UDTs
RDI_PROC RDIM_UDT *
rdim_udt_chunk_list_push(RDIM_Arena *arena, RDIM_UDTChunkList *list, RDI_U64 cap)
{
RDIM_IdxedChunkListPush(arena, list, RDIM_UDTChunkNode, RDIM_UDT, cap, result);
return result;
}
RDI_PROC RDI_U64
rdim_idx_from_udt(RDIM_UDT *udt)
{
RDIM_IdxedChunkListElementGetIdx(udt, idx);
return idx;
}
RDI_PROC void
rdim_udt_chunk_list_concat_in_place(RDIM_UDTChunkList *dst, RDIM_UDTChunkList *to_push)
{
RDIM_IdxedChunkListConcatInPlace(RDIM_UDTChunkNode, dst, to_push,
dst->total_member_count += to_push->total_member_count,
dst->total_enum_val_count += to_push->total_enum_val_count);
}
RDI_PROC RDIM_UDTMember *
rdim_udt_push_member(RDIM_Arena *arena, RDIM_UDTChunkList *list, RDIM_UDT *udt)
{
RDIM_UDTMember *mem = rdim_push_array(arena, RDIM_UDTMember, 1);
RDIM_SLLQueuePush(udt->first_member, udt->last_member, mem);
udt->member_count += 1;
list->total_member_count += 1;
return mem;
}
RDI_PROC RDIM_UDTEnumVal *
rdim_udt_push_enum_val(RDIM_Arena *arena, RDIM_UDTChunkList *list, RDIM_UDT *udt)
{
RDIM_UDTEnumVal *mem = rdim_push_array(arena, RDIM_UDTEnumVal, 1);
RDIM_SLLQueuePush(udt->first_enum_val, udt->last_enum_val, mem);
udt->enum_val_count += 1;
list->total_enum_val_count += 1;
return mem;
}
////////////////////////////////
//~ rjf: [Building] Symbol Info Building
RDI_PROC RDIM_Symbol *
rdim_symbol_chunk_list_push(RDIM_Arena *arena, RDIM_SymbolChunkList *list, RDI_U64 cap)
{
RDIM_IdxedChunkListPush(arena, list, RDIM_SymbolChunkNode, RDIM_Symbol, cap, result);
return result;
}
RDI_PROC RDI_U64
rdim_idx_from_symbol(RDIM_Symbol *symbol)
{
RDIM_IdxedChunkListElementGetIdx(symbol, idx);
return idx;
}
RDI_PROC void
rdim_symbol_chunk_list_concat_in_place(RDIM_SymbolChunkList *dst, RDIM_SymbolChunkList *to_push)
{
RDIM_IdxedChunkListConcatInPlace(RDIM_SymbolChunkNode, dst, to_push, dst->total_value_data_size += to_push->total_value_data_size);
}
internal void
rdim_symbol_push_value_data(RDIM_Arena *arena, RDIM_SymbolChunkList *list, RDIM_Symbol *symbol, RDIM_String8 data)
{
symbol->value_data = rdim_str8_copy(arena, data);
list->total_value_data_size += data.size;
}
////////////////////////////////
//~ rjf: [Building] Inline Site Info Building
RDI_PROC RDIM_InlineSite *
rdim_inline_site_chunk_list_push(RDIM_Arena *arena, RDIM_InlineSiteChunkList *list, RDI_U64 cap)
{
RDIM_IdxedChunkListPush(arena, list, RDIM_InlineSiteChunkNode, RDIM_InlineSite, cap, result);
return result;
}
RDI_PROC RDI_U64
rdim_idx_from_inline_site(RDIM_InlineSite *inline_site)
{
RDIM_IdxedChunkListElementGetIdx(inline_site, idx);
return idx;
}
RDI_PROC void
rdim_inline_site_chunk_list_concat_in_place(RDIM_InlineSiteChunkList *dst, RDIM_InlineSiteChunkList *to_push)
{
RDIM_IdxedChunkListConcatInPlace(RDIM_InlineSiteChunkNode, dst, to_push);
}
////////////////////////////////
//~ rjf: [Building] Location Info Building
//- rjf: bytecode
RDI_PROC void
rdim_bytecode_push_op(RDIM_Arena *arena, RDIM_EvalBytecode *bytecode, RDI_EvalOp op, RDI_U64 p)
{
RDI_U16 ctrlbits = rdi_eval_op_ctrlbits_table[op];
RDI_U32 p_size = RDI_DECODEN_FROM_CTRLBITS(ctrlbits);
RDIM_EvalBytecodeOp *node = rdim_push_array(arena, RDIM_EvalBytecodeOp, 1);
node->op = op;
node->p_size = p_size;
node->p = p;
RDIM_SLLQueuePush(bytecode->first_op, bytecode->last_op, node);
bytecode->op_count += 1;
bytecode->encoded_size += 1 + p_size;
}
RDI_PROC void
rdim_bytecode_push_uconst(RDIM_Arena *arena, RDIM_EvalBytecode *bytecode, RDI_U64 x)
{
if(x <= 0xFF)
{
rdim_bytecode_push_op(arena, bytecode, RDI_EvalOp_ConstU8, x);
}
else if(x <= 0xFFFF)
{
rdim_bytecode_push_op(arena, bytecode, RDI_EvalOp_ConstU16, x);
}
else if(x <= 0xFFFFFFFF)
{
rdim_bytecode_push_op(arena, bytecode, RDI_EvalOp_ConstU32, x);
}
else
{
rdim_bytecode_push_op(arena, bytecode, RDI_EvalOp_ConstU64, x);
}
}
RDI_PROC void
rdim_bytecode_push_sconst(RDIM_Arena *arena, RDIM_EvalBytecode *bytecode, RDI_S64 x)
{
if(-0x80 <= x && x <= 0x7F)
{
rdim_bytecode_push_op(arena, bytecode, RDI_EvalOp_ConstU8, (RDI_U64)x);
rdim_bytecode_push_op(arena, bytecode, RDI_EvalOp_TruncSigned, 8);
}
else if(-0x8000 <= x && x <= 0x7FFF)
{
rdim_bytecode_push_op(arena, bytecode, RDI_EvalOp_ConstU16, (RDI_U64)x);
rdim_bytecode_push_op(arena, bytecode, RDI_EvalOp_TruncSigned, 16);
}
else if(-0x80000000ll <= x && x <= 0x7FFFFFFFll)
{
rdim_bytecode_push_op(arena, bytecode, RDI_EvalOp_ConstU32, (RDI_U64)x);
rdim_bytecode_push_op(arena, bytecode, RDI_EvalOp_TruncSigned, 32);
}
else
{
rdim_bytecode_push_op(arena, bytecode, RDI_EvalOp_ConstU64, (RDI_U64)x);
}
}
RDI_PROC void
rdim_bytecode_concat_in_place(RDIM_EvalBytecode *left_dst, RDIM_EvalBytecode *right_destroyed)
{
if(right_destroyed->first_op != 0)
{
if(left_dst->first_op == 0)
{
rdim_memcpy_struct(left_dst, right_destroyed);
}
else
{
left_dst->last_op->next = right_destroyed->first_op;
left_dst->last_op = right_destroyed->last_op;
left_dst->op_count += right_destroyed->op_count;
left_dst->encoded_size += right_destroyed->encoded_size;
}
rdim_memzero_struct(right_destroyed);
}
}
//- rjf: locations
RDI_PROC RDI_U64
rdim_encoded_size_from_location_info(RDIM_LocationInfo *info)
{
RDI_U64 result = 0;
switch((RDI_LocationKindEnum)info->kind)
{
case RDI_LocationKind_NULL:{}break;
case RDI_LocationKind_AddrBytecodeStream:
case RDI_LocationKind_ValBytecodeStream:
{
result = sizeof(RDI_LocationBytecodeStream) + info->bytecode.encoded_size + 1;
}break;
case RDI_LocationKind_AddrRegPlusU16:
case RDI_LocationKind_AddrAddrRegPlusU16:
{
result = sizeof(RDI_LocationRegPlusU16);
}break;
case RDI_LocationKind_ValReg:
{
result = sizeof(RDI_LocationReg);
}break;
}
return result;
}
RDI_PROC RDIM_Location *
rdim_location_chunk_list_push_new(RDIM_Arena *arena, RDIM_LocationChunkList *list, RDI_U64 cap, RDIM_LocationInfo *info)
{
RDIM_IdxedChunkListPush(arena, list, RDIM_LocationChunkNode, RDIM_Location, cap, result, n->base_encoding_off = list->total_encoded_size);
{
RDI_U64 encoded_size = rdim_encoded_size_from_location_info(info);
rdim_memcpy_struct(&result->info, info);
result->relative_encoding_off = list->last->encoded_size;
list->last->encoded_size += encoded_size;
list->total_encoded_size += encoded_size;
}
return result;
}
RDI_PROC RDI_U64
rdim_off_from_location(RDIM_Location *location)
{
RDI_U64 off = 0;
if(location != 0 && location->chunk != 0)
{
off = location->chunk->base_encoding_off + location->relative_encoding_off + 1;
}
return off;
}
RDI_PROC void
rdim_location_chunk_list_concat_in_place(RDIM_LocationChunkList *dst, RDIM_LocationChunkList *to_push)
{
for(RDIM_LocationChunkNode *n = to_push->first; n != 0; n = n->next)
{
n->base_encoding_off += dst->total_encoded_size;
}
RDIM_IdxedChunkListConcatInPlace(RDIM_LocationChunkNode, dst, to_push, dst->total_encoded_size += to_push->total_encoded_size);
}
////////////////////////////////
//~ rjf: [Building] Scope Info Building
RDI_PROC RDIM_Scope *
rdim_scope_chunk_list_push(RDIM_Arena *arena, RDIM_ScopeChunkList *list, RDI_U64 cap)
{
RDIM_IdxedChunkListPush(arena, list, RDIM_ScopeChunkNode, RDIM_Scope, cap, result);
return result;
}
RDI_PROC RDI_U64
rdim_idx_from_scope(RDIM_Scope *scope)
{
RDIM_IdxedChunkListElementGetIdx(scope, idx);
return idx;
}
RDI_PROC void
rdim_scope_chunk_list_concat_in_place(RDIM_ScopeChunkList *dst, RDIM_ScopeChunkList *to_push)
{
RDIM_IdxedChunkListConcatInPlace(RDIM_ScopeChunkNode, dst, to_push,
dst->scope_voff_count += to_push->scope_voff_count,
dst->local_count += to_push->local_count,
dst->location_case_count += to_push->location_case_count);
}
RDI_PROC void
rdim_scope_push_voff_range(RDIM_Arena *arena, RDIM_ScopeChunkList *list, RDIM_Scope *scope, RDIM_Rng1U64 range)
{
rdim_rng1u64_list_push(arena, &scope->voff_ranges, range);
list->scope_voff_count += 2;
}
RDI_PROC RDIM_Local *
rdim_scope_push_local(RDIM_Arena *arena, RDIM_ScopeChunkList *scopes, RDIM_Scope *scope)
{
RDIM_Local *local = rdim_push_array(arena, RDIM_Local, 1);
RDIM_SLLQueuePush(scope->first_local, scope->last_local, local);
scope->local_count += 1;
scopes->local_count += 1;
return local;
}
RDI_PROC RDIM_LocationCase *
rdim_local_push_location_case(RDIM_Arena *arena, RDIM_ScopeChunkList *scopes, RDIM_Local *local, RDIM_Location *location, RDIM_Rng1U64 voff_range)
{
RDIM_LocationCase *loc_case = rdim_push_array(arena, RDIM_LocationCase, 1);
RDIM_SLLQueuePush(local->location_cases.first, local->location_cases.last, loc_case);
local->location_cases.count += 1;
loc_case->location = location;
loc_case->voff_range = voff_range;
scopes->location_case_count += 1;
return loc_case;
}
////////////////////////////////
//~ rjf: [Baking Helpers] Deduplicated String Baking Map
//- rjf: chunk lists
RDI_PROC RDIM_BakeString *
rdim_bake_string_chunk_list_push(RDIM_Arena *arena, RDIM_BakeStringChunkList *list, RDI_U64 cap)
{
RDIM_BakeStringChunkNode *n = list->last;
if(n == 0 || n->count >= n->cap)
{
n = rdim_push_array(arena, RDIM_BakeStringChunkNode, 1);
n->cap = cap;
n->v = rdim_push_array(arena, RDIM_BakeString, n->cap);
RDIM_SLLQueuePush(list->first, list->last, n);
list->chunk_count += 1;
}
RDIM_BakeString *s = &n->v[n->count];
n->count += 1;
list->total_count += 1;
return s;
}
RDI_PROC void
rdim_bake_string_chunk_list_concat_in_place(RDIM_BakeStringChunkList *dst, RDIM_BakeStringChunkList *to_push)
{
for(RDIM_BakeStringChunkNode *n = to_push->first; n != 0; n = n->next)
{
n->base_idx += dst->total_count;
}
if(dst->last != 0 && to_push->first != 0)
{
dst->last->next = to_push->first;
dst->last = to_push->last;
dst->chunk_count += to_push->chunk_count;
dst->total_count += to_push->total_count;
}
else if(dst->first == 0)
{
rdim_memcpy_struct(dst, to_push);
}
rdim_memzero_struct(to_push);
}
RDI_PROC RSFORCEINLINE int
rdim_bake_string_is_before(void *l, void *r)
{
return str8_is_before(((RDIM_BakeString *)l)->string, ((RDIM_BakeString *)r)->string);
}
RDI_PROC RDIM_BakeStringChunkList
rdim_bake_string_chunk_list_sorted_from_unsorted(RDIM_Arena *arena, RDIM_BakeStringChunkList *src)
{
//- rjf: produce unsorted destination list with single chunk node
RDIM_BakeStringChunkList dst = {0};
for(RDIM_BakeStringChunkNode *n = src->first; n != 0; n = n->next)
{
for(RDI_U64 idx = 0; idx < n->count; idx += 1)
{
RDIM_BakeString *src_str = &n->v[idx];
RDIM_BakeString *dst_str = rdim_bake_string_chunk_list_push(arena, &dst, src->total_count);
rdim_memcpy_struct(dst_str, src_str);
}
}
//- rjf: sort chunk node
if(dst.first != 0)
{
radsort(dst.first->v, dst.first->count, rdim_bake_string_is_before);
}
//- rjf: iterate sorted chunk node, remove duplicates, count # of duplicates
RDI_U64 num_duplicates = 0;
if(dst.first != 0)
{
RDI_U64 last_idx = 0;
for(RDI_U64 idx = 1; idx < dst.first->count; idx += 1)
{
if(rdim_str8_match(dst.first->v[last_idx].string, dst.first->v[idx].string, 0))
{
rdim_memzero_struct(&dst.first->v[idx]);
num_duplicates += 1;
}
else
{
last_idx = idx;
}
}
}
//- rjf: iterate sorted chunk node, make non-empty elements contiguous
if(num_duplicates != 0)
{
RDI_U64 last_idx = 0;
for(RDI_U64 idx = 1; idx < dst.first->count; idx += 1)
{
if(last_idx == 0 &&
dst.first->v[idx].string.RDIM_String8_SizeMember == 0 &&
dst.first->v[idx].hash == 0)
{
last_idx = idx;
}
if(last_idx != 0 && dst.first->v[idx].string.RDIM_String8_SizeMember != 0)
{
rdim_memcpy_struct(&dst.first->v[last_idx], &dst.first->v[idx]);
rdim_memzero_struct(&dst.first->v[idx]);
last_idx += 1;
}
}
//- rjf: pop extras
if(num_duplicates != 0)
{
RDI_U64 arena_pos_pre_pop = rdim_arena_pos(arena);
rdim_arena_pop_to(arena, arena_pos_pre_pop - num_duplicates*sizeof(dst.first->v[0]));
dst.first->count -= num_duplicates;
dst.first->cap -= num_duplicates;
dst.total_count -= num_duplicates;
}
}
return dst;
}
//- rjf: loose map
RDI_PROC RDIM_BakeStringMapLoose *
rdim_bake_string_map_loose_make(RDIM_Arena *arena, RDIM_BakeStringMapTopology *top)
{
RDIM_BakeStringMapLoose *map = rdim_push_array(arena, RDIM_BakeStringMapLoose, 1);
map->slots = rdim_push_array(arena, RDIM_BakeStringChunkList *, top->slots_count);
return map;
}
RDI_PROC void
rdim_bake_string_map_loose_insert(RDIM_Arena *arena, RDIM_BakeStringMapTopology *map_topology, RDIM_BakeStringMapLoose *map, RDI_U64 chunk_cap, RDIM_String8 string)
{
if(string.RDIM_String8_SizeMember != 0)
{
RDI_U64 hash = rdi_hash(string.RDIM_String8_BaseMember, string.RDIM_String8_SizeMember);
RDI_U64 slot_idx = hash%map_topology->slots_count;
RDIM_BakeStringChunkList *slot = map->slots[slot_idx];
if(slot == 0)
{
slot = map->slots[slot_idx] = rdim_push_array(arena, RDIM_BakeStringChunkList, 1);
}
RDI_S32 is_duplicate = 0;
for(RDIM_BakeStringChunkNode *n = slot->first; n != 0; n = n->next)
{
for(RDI_U64 idx = 0; idx < n->count; idx += 1)
{
if(rdim_str8_match(n->v[idx].string, string, 0))
{
is_duplicate = 1;
goto break_all;
}
}
}
break_all:;
if(!is_duplicate)
{
RDIM_BakeString *bstr = rdim_bake_string_chunk_list_push(arena, slot, chunk_cap);
bstr->string = string;
bstr->hash = hash;
}
}
}
RDI_PROC RDIM_BakeStringMapBaseIndices
rdim_bake_string_map_base_indices_from_map_loose(RDIM_Arena *arena, RDIM_BakeStringMapTopology *map_topology, RDIM_BakeStringMapLoose *map)
{
RDIM_BakeStringMapBaseIndices indices = {0};
indices.slots_base_idxs = rdim_push_array(arena, RDI_U64, map_topology->slots_count+1);
RDI_U64 total_count = 0;
for(RDI_U64 idx = 0; idx < map_topology->slots_count; idx += 1)
{
indices.slots_base_idxs[idx] += total_count;
if(map->slots[idx] != 0)
{
total_count += map->slots[idx]->total_count;
}
}
indices.slots_base_idxs[map_topology->slots_count] = total_count;
return indices;
}
//- rjf: finalized / tight map
RDI_PROC RDI_U32
rdim_bake_idx_from_string(RDIM_BakeStringMapTight *map, RDIM_String8 string)
{
RDI_U32 idx = 0;
if(string.RDIM_String8_SizeMember != 0)
{
RDI_U64 hash = rdi_hash(string.RDIM_String8_BaseMember, string.RDIM_String8_SizeMember);
RDI_U64 slot_idx = hash%map->slots_count;
for(RDIM_BakeStringChunkNode *n = map->slots[slot_idx].first; n != 0; n = n->next)
{
for(RDI_U64 chunk_idx = 0; chunk_idx < n->count; chunk_idx += 1)
{
if(n->v[chunk_idx].hash == hash && rdim_str8_match(n->v[chunk_idx].string, string, 0))
{
idx = map->slots_base_idxs[slot_idx] + n->base_idx + chunk_idx + 1;
break;
}
}
}
}
return idx;
}
////////////////////////////////
//~ rjf: [Baking Helpers] Deduplicated Index Run Baking Map
//- rjf: bake idx run map reading/writing
RDI_PROC RDI_U64
rdim_hash_from_idx_run(RDI_U32 *idx_run, RDI_U32 count)
{
RDI_U64 hash = 5381;
RDI_U32 *ptr = idx_run;
RDI_U32 *opl = idx_run + count;
for(;ptr < opl; ptr += 1)
{
hash = ((hash << 5) + hash) + (*ptr);
}
return hash;
}
//- rjf: chunk lists
RDI_PROC RDIM_BakeIdxRun *
rdim_bake_idx_run_chunk_list_push(RDIM_Arena *arena, RDIM_BakeIdxRunChunkList *list, RDI_U64 cap)
{
RDIM_BakeIdxRunChunkNode *n = list->last;
if(n == 0 || n->count >= n->cap)
{
n = rdim_push_array(arena, RDIM_BakeIdxRunChunkNode, 1);
n->cap = cap;
n->v = rdim_push_array(arena, RDIM_BakeIdxRun, n->cap);
RDIM_SLLQueuePush(list->first, list->last, n);
list->chunk_count += 1;
}
RDIM_BakeIdxRun *s = &n->v[n->count];
n->count += 1;
list->total_count += 1;
return s;
}
RDI_PROC void
rdim_bake_idx_run_chunk_list_concat_in_place(RDIM_BakeIdxRunChunkList *dst, RDIM_BakeIdxRunChunkList *to_push)
{
if(dst->last != 0 && to_push->first != 0)
{
dst->last->next = to_push->first;
dst->last = to_push->last;
dst->chunk_count += to_push->chunk_count;
dst->total_count += to_push->total_count;
}
else if(dst->first == 0)
{
rdim_memcpy_struct(dst, to_push);
}
rdim_memzero_struct(to_push);
}
RDI_PROC RSFORCEINLINE int
rdim_bake_idx_run_is_before(void *l, void *r)
{
B32 is_less_than = 0;
{
RDIM_BakeIdxRun *lir = (RDIM_BakeIdxRun *)l;
RDIM_BakeIdxRun *rir = (RDIM_BakeIdxRun *)r;
U64 common_count = Min(lir->count, rir->count);
for(U64 off = 0; off < common_count; off += 1)
{
if(lir->idxes[off] < rir->idxes[off])
{
is_less_than = 1;
break;
}
else if(lir->idxes[off] > rir->idxes[off])
{
is_less_than = 0;
break;
}
else if(off+1 == common_count)
{
is_less_than = (lir->count < rir->count);
}
}
}
return is_less_than;
}
RDI_PROC RDIM_BakeIdxRunChunkList
rdim_bake_idx_run_chunk_list_sorted_from_unsorted(RDIM_Arena *arena, RDIM_BakeIdxRunChunkList *src)
{
//- rjf: produce unsorted destination list with single chunk node
RDIM_BakeIdxRunChunkList dst = {0};
for(RDIM_BakeIdxRunChunkNode *n = src->first; n != 0; n = n->next)
{
for(RDI_U64 idx = 0; idx < n->count; idx += 1)
{
RDIM_BakeIdxRun *src_str = &n->v[idx];
RDIM_BakeIdxRun *dst_str = rdim_bake_idx_run_chunk_list_push(arena, &dst, src->total_count);
rdim_memcpy_struct(dst_str, src_str);
}
}
//- rjf: sort chunk node
if(dst.first != 0)
{
radsort(dst.first->v, dst.first->count, rdim_bake_idx_run_is_before);
}
//- rjf: iterate sorted chunk node, remove duplicates, count # of duplicates
RDI_U64 num_duplicates = 0;
if(dst.first != 0)
{
RDI_U64 last_idx = 0;
for(RDI_U64 idx = 1; idx < dst.first->count; idx += 1)
{
if(dst.first->v[last_idx].count == dst.first->v[idx].count &&
MemoryMatch(dst.first->v[last_idx].idxes,
dst.first->v[idx].idxes,
sizeof(dst.first->v[idx].idxes[0]) * dst.first->v[idx].count))
{
rdim_memzero_struct(&dst.first->v[idx]);
num_duplicates += 1;
}
else
{
last_idx = idx;
}
}
}
//- rjf: iterate sorted chunk node, make non-empty elements contiguous
if(num_duplicates != 0)
{
RDI_U64 last_idx = 0;
for(RDI_U64 idx = 1; idx < dst.first->count; idx += 1)
{
if(last_idx == 0 && dst.first->v[idx].hash == 0)
{
last_idx = idx;
}
if(last_idx != 0 && dst.first->v[idx].hash != 0)
{
rdim_memcpy_struct(&dst.first->v[last_idx], &dst.first->v[idx]);
rdim_memzero_struct(&dst.first->v[idx]);
last_idx += 1;
}
}
//- rjf: pop extras
if(num_duplicates != 0)
{
RDI_U64 arena_pos_pre_pop = rdim_arena_pos(arena);
rdim_arena_pop_to(arena, arena_pos_pre_pop - num_duplicates*sizeof(dst.first->v[0]));
dst.first->count -= num_duplicates;
dst.first->cap -= num_duplicates;
dst.total_count -= num_duplicates;
}
}
return dst;
}
//- rjf: loose map
RDI_PROC RDIM_BakeIdxRunMapLoose *
rdim_bake_idx_run_map_loose_make(RDIM_Arena *arena, RDIM_BakeIdxRunMapTopology *top)
{
RDIM_BakeIdxRunMapLoose *map = rdim_push_array(arena, RDIM_BakeIdxRunMapLoose, 1);
map->slots = rdim_push_array(arena, RDIM_BakeIdxRunChunkList *, top->slots_count);
map->slots_idx_counts = rdim_push_array(arena, RDI_U64, top->slots_count);
return map;
}
RDI_PROC void
rdim_bake_idx_run_map_loose_insert(RDIM_Arena *arena, RDIM_BakeIdxRunMapTopology *map_topology, RDIM_BakeIdxRunMapLoose *map, RDI_U64 chunk_cap, RDI_U32 *idxes, RDI_U32 count)
{
if(count != 0)
{
RDI_U64 hash = rdim_hash_from_idx_run(idxes, count);
RDI_U64 slot_idx = hash%map_topology->slots_count;
RDIM_BakeIdxRunChunkList *slot = map->slots[slot_idx];
if(slot == 0)
{
slot = map->slots[slot_idx] = rdim_push_array(arena, RDIM_BakeIdxRunChunkList, 1);
}
RDI_S32 is_duplicate = 0;
for(RDIM_BakeIdxRunChunkNode *n = slot->first; n != 0; n = n->next)
{
for(RDI_U64 idx = 0; idx < n->count; idx += 1)
{
if(n->v[idx].hash == hash &&
n->v[idx].count == count &&
MemoryMatch(n->v[idx].idxes, idxes, sizeof(idxes[0])*count))
{
is_duplicate = 1;
goto break_all;
}
}
}
break_all:;
if(!is_duplicate)
{
RDIM_BakeIdxRun *bir = rdim_bake_idx_run_chunk_list_push(arena, slot, chunk_cap);
bir->hash = hash;
bir->count = count;
bir->idxes = idxes;
map->slots_idx_counts[slot_idx] += count;
}
}
}
//- rjf: finalized / tight map
RDI_PROC RDI_U32
rdim_bake_idx_from_idx_run(RDIM_BakeIdxRunMap *map, RDI_U32 *idxes, RDI_U32 count)
{
RDI_U32 idx = 0;
if(count != 0)
{
RDI_U64 hash = rdim_hash_from_idx_run(idxes, count);
RDI_U64 slot_idx = hash%map->slots_count;
RDI_U64 off = 0;
for(RDIM_BakeIdxRunChunkNode *n = map->slots[slot_idx].first; n != 0; n = n->next)
{
for(RDI_U64 chunk_idx = 0; chunk_idx < n->count; chunk_idx += 1)
{
if(n->v[chunk_idx].hash == hash &&
n->v[chunk_idx].count == count &&
MemoryMatch(n->v[chunk_idx].idxes, idxes, sizeof(idxes[0])*count))
{
idx = (RDI_U32)(map->slots_base_idxs[slot_idx] + off); // TODO(rjf): @u64_to_u32
goto end_lookup;
}
off += n->v[chunk_idx].count;
}
}
end_lookup:;
}
return idx;
}
////////////////////////////////
//~ rjf: [Baking Helpers] Deduplicated Name Map Baking Map
//- rjf: chunk lists
RDI_PROC RDIM_BakeName *
rdim_bake_name_chunk_list_push(RDIM_Arena *arena, RDIM_BakeNameChunkList *list, RDI_U64 cap)
{
RDIM_BakeNameChunkNode *n = list->last;
if(n == 0 || n->count >= n->cap)
{
n = rdim_push_array(arena, RDIM_BakeNameChunkNode, 1);
n->cap = cap;
n->base_idx = list->total_count;
n->v = rdim_push_array(arena, RDIM_BakeName, n->cap);
RDIM_SLLQueuePush(list->first, list->last, n);
list->chunk_count += 1;
}
RDIM_BakeName *result = &n->v[n->count];
n->count += 1;
list->total_count += 1;
return result;
}
RDI_PROC void
rdim_bake_name_chunk_list_concat_in_place(RDIM_BakeNameChunkList *dst, RDIM_BakeNameChunkList *to_push)
{
for(RDIM_BakeNameChunkNode *n = to_push->first; n != 0; n = n->next)
{
n->base_idx += dst->total_count;
}
if(dst->last != 0 && to_push->first != 0)
{
dst->last->next = to_push->first;
dst->last = to_push->last;
dst->chunk_count += to_push->chunk_count;
dst->total_count += to_push->total_count;
}
else if(dst->first == 0)
{
rdim_memcpy_struct(dst, to_push);
}
rdim_memzero_struct(to_push);
}
RDI_PROC RSFORCEINLINE int
rdim_bake_name_is_before(void *l, void *r)
{
RDIM_BakeName *lhs = (RDIM_BakeName *)l;
RDIM_BakeName *rhs = (RDIM_BakeName *)r;
B32 lhs_name_lt = str8_is_before(lhs->string, rhs->string);
B32 is_before = lhs_name_lt;
if(!lhs_name_lt)
{
B32 rhs_name_lt = str8_is_before(rhs->string, lhs->string);
if(!rhs_name_lt)
{
is_before = (lhs->idx > rhs->idx);
}
}
return is_before;
}
RDI_PROC RDIM_BakeNameChunkList
rdim_bake_name_chunk_list_sorted_from_unsorted(RDIM_Arena *arena, RDIM_BakeNameChunkList *src)
{
//- rjf: produce unsorted destination list with single chunk node
RDIM_BakeNameChunkList dst = {0};
for(RDIM_BakeNameChunkNode *n = src->first; n != 0; n = n->next)
{
for(RDI_U64 idx = 0; idx < n->count; idx += 1)
{
RDIM_BakeName *src_str = &n->v[idx];
RDIM_BakeName *dst_str = rdim_bake_name_chunk_list_push(arena, &dst, src->total_count);
rdim_memcpy_struct(dst_str, src_str);
}
}
//- rjf: sort chunk node
if(dst.first != 0)
{
radsort(dst.first->v, dst.first->count, rdim_bake_name_is_before);
}
//- rjf: iterate sorted chunk node, remove duplicates, count # of duplicates
RDI_U64 num_duplicates = 0;
if(dst.first != 0)
{
RDI_U64 last_idx = 0;
for(RDI_U64 idx = 1; idx < dst.first->count; idx += 1)
{
if(rdim_str8_match(dst.first->v[last_idx].string, dst.first->v[idx].string, 0) &&
dst.first->v[last_idx].idx == dst.first->v[idx].idx)
{
rdim_memzero_struct(&dst.first->v[idx]);
num_duplicates += 1;
}
else
{
last_idx = idx;
}
}
}
//- rjf: iterate sorted chunk node, make non-empty elements contiguous
if(num_duplicates != 0)
{
RDI_U64 last_idx = 0;
for(RDI_U64 idx = 1; idx < dst.first->count; idx += 1)
{
if(last_idx == 0 &&
dst.first->v[idx].string.RDIM_String8_SizeMember == 0 &&
dst.first->v[idx].hash == 0)
{
last_idx = idx;
}
if(last_idx != 0 && dst.first->v[idx].string.RDIM_String8_SizeMember != 0)
{
rdim_memcpy_struct(&dst.first->v[last_idx], &dst.first->v[idx]);
rdim_memzero_struct(&dst.first->v[idx]);
last_idx += 1;
}
}
//- rjf: pop extras
if(num_duplicates != 0)
{
RDI_U64 arena_pos_pre_pop = rdim_arena_pos(arena);
rdim_arena_pop_to(arena, arena_pos_pre_pop - num_duplicates*sizeof(dst.first->v[0]));
dst.first->count -= num_duplicates;
dst.first->cap -= num_duplicates;
dst.total_count -= num_duplicates;
}
}
return dst;
}
//- rjf: bake name chunk list maps
RDI_PROC RDIM_BakeNameMap *
rdim_bake_name_map_make(RDIM_Arena *arena, RDIM_BakeNameMapTopology *top)
{
RDIM_BakeNameMap *map = rdim_push_array(arena, RDIM_BakeNameMap, 1);
map->slots = rdim_push_array(arena, RDIM_BakeNameChunkList *, top->slots_count);
return map;
}
RDI_PROC void
rdim_bake_name_map_insert(RDIM_Arena *arena, RDIM_BakeNameMapTopology *map_topology, RDIM_BakeNameMap *map, RDI_U64 chunk_cap, RDIM_String8 string, RDI_U64 idx)
{
if(string.RDIM_String8_SizeMember != 0)
{
RDI_U64 hash = rdi_hash(string.RDIM_String8_BaseMember, string.RDIM_String8_SizeMember);
RDI_U64 slot_idx = hash%map_topology->slots_count;
RDIM_BakeNameChunkList *slot = map->slots[slot_idx];
if(slot == 0)
{
slot = map->slots[slot_idx] = rdim_push_array(arena, RDIM_BakeNameChunkList, 1);
}
RDI_S32 is_duplicate = 0;
for(RDIM_BakeNameChunkNode *n = slot->first; n != 0; n = n->next)
{
for(RDI_U64 idx = 0; idx < n->count; idx += 1)
{
if(rdim_str8_match(n->v[idx].string, string, 0) &&
n->v[idx].idx == idx)
{
is_duplicate = 1;
goto break_all;
}
}
}
break_all:;
if(!is_duplicate)
{
RDIM_BakeName *bstr = rdim_bake_name_chunk_list_push(arena, slot, chunk_cap);
bstr->string = string;
bstr->idx = idx;
bstr->hash = hash;
}
}
}
////////////////////////////////
//~ rjf: [Baking Helpers] Deduplicated Path Baking Tree
RDI_PROC RDIM_BakePathNode *
rdim_bake_path_node_from_string(RDIM_BakePathTree *tree, RDIM_String8 string)
{
RDIM_BakePathNode *node = &tree->root;
RDI_U8 *ptr = string.str;
RDI_U8 *opl = string.str + string.size;
for(;ptr < opl && node != 0;)
{
// rjf: skip past slashes
for(;ptr < opl && (*ptr == '/' || *ptr == '\\'); ptr += 1);
// rjf: save beginning of non-slash range
RDI_U8 *range_first = ptr;
// rjf: skip past non-slashes
for(;ptr < opl && !(*ptr == '/' || *ptr == '\\'); ptr += 1);
// rjf: empty range -> continue
if(range_first >= ptr)
{
continue;
}
// rjf: range -> sub-directory string
RDIM_String8 sub_dir = rdim_str8(range_first, (RDI_U64)(ptr-range_first));
// rjf: sub-directory string -> find child of node
RDIM_BakePathNode *sub_dir_node = 0;
for(RDIM_BakePathNode *child = node->first_child; child != 0; child = child->next_sibling)
{
if(rdim_str8_match(child->name, sub_dir, 0))
{
sub_dir_node = child;
}
}
// rjf: .. -> go up
if(sub_dir.RDIM_String8_SizeMember == 2 &&
sub_dir.RDIM_String8_BaseMember[0] == '.' &&
sub_dir.RDIM_String8_BaseMember[1] == '.')
{
sub_dir_node = node->parent;
if(sub_dir_node == 0)
{
sub_dir_node = &tree->root;
}
}
// rjf: . -> stay here
else if(sub_dir.RDIM_String8_SizeMember == 1 &&
sub_dir.RDIM_String8_BaseMember[0] == '.')
{
sub_dir_node = node;
}
// rjf: descend to child
node = sub_dir_node;
}
return node;
}
RDI_PROC RDI_U32
rdim_bake_path_node_idx_from_string(RDIM_BakePathTree *tree, RDIM_String8 string)
{
RDIM_BakePathNode *path_node = rdim_bake_path_node_from_string(tree, string);
RDI_U32 result = 0;
if(path_node != 0)
{
result = path_node->idx;
}
return result;
}
RDI_PROC RDIM_BakePathNode *
rdim_bake_path_tree_insert(RDIM_Arena *arena, RDIM_BakePathTree *tree, RDIM_String8 string)
{
RDIM_BakePathNode *node = &tree->root;
RDI_U8 *ptr = string.str;
RDI_U8 *opl = string.str + string.size;
for(;ptr < opl;)
{
// rjf: skip past slashes
for(;ptr < opl && (*ptr == '/' || *ptr == '\\'); ptr += 1);
// rjf: save beginning of non-slash range
RDI_U8 *range_first = ptr;
// rjf: skip past non-slashes
for(;ptr < opl && !(*ptr == '/' || *ptr == '\\'); ptr += 1);
// rjf: empty range -> continue
if(range_first >= ptr)
{
continue;
}
// rjf: range -> sub-directory string
RDIM_String8 sub_dir = rdim_str8(range_first, (RDI_U64)(ptr-range_first));
// rjf: sub-directory string -> find child of node
RDIM_BakePathNode *sub_dir_node = 0;
for(RDIM_BakePathNode *child = node->first_child; child != 0; child = child->next_sibling)
{
if(rdim_str8_match(child->name, sub_dir, 0))
{
sub_dir_node = child;
}
}
// rjf: .. -> go up
if(sub_dir.RDIM_String8_SizeMember == 2 &&
sub_dir.RDIM_String8_BaseMember[0] == '.' &&
sub_dir.RDIM_String8_BaseMember[1] == '.')
{
sub_dir_node = node->parent;
if(sub_dir_node == 0)
{
sub_dir_node = &tree->root;
}
}
// rjf: . -> stay here
else if(sub_dir.RDIM_String8_SizeMember == 1 &&
sub_dir.RDIM_String8_BaseMember[0] == '.')
{
sub_dir_node = node;
}
// rjf: no child -> make one
else if(sub_dir_node == 0)
{
sub_dir_node = rdim_push_array(arena, RDIM_BakePathNode, 1);
RDIM_SLLQueuePush_N(tree->first, tree->last, sub_dir_node, next_order);
sub_dir_node->parent = node;
RDIM_SLLQueuePush_N(node->first_child, node->last_child, sub_dir_node, next_sibling);
sub_dir_node->name = rdim_str8_copy(arena, sub_dir);
sub_dir_node->idx = tree->count;
tree->count += 1;
}
// rjf: descend to child
node = sub_dir_node;
}
return node;
}
////////////////////////////////
//~ rjf: [Baking Helpers] Data Section List Building Helpers
RDI_PROC RDIM_BakeSection *
rdim_bake_section_list_push(RDIM_Arena *arena, RDIM_BakeSectionList *list)
{
RDIM_BakeSectionNode *n = rdim_push_array(arena, RDIM_BakeSectionNode, 1);
RDIM_SLLQueuePush(list->first, list->last, n);
list->count += 1;
RDIM_BakeSection *result = &n->v;
return result;
}
RDI_PROC RDIM_BakeSection *
rdim_bake_section_list_push_new_unpacked(RDIM_Arena *arena, RDIM_BakeSectionList *list, void *data, RDI_U64 size, RDI_SectionKind tag, RDI_U64 tag_idx)
{
RDIM_BakeSection *section = rdim_bake_section_list_push(arena, list);
section->data = data;
section->encoding = RDI_SectionEncoding_Unpacked;
section->encoded_size = size;
section->unpacked_size = size;
section->tag = tag;
section->tag_idx = tag_idx;
return section;
}
RDI_PROC void
rdim_bake_section_list_concat_in_place(RDIM_BakeSectionList *dst, RDIM_BakeSectionList *to_push)
{
if(dst->last != 0 && to_push->first != 0)
{
dst->last->next = to_push->first;
dst->last = to_push->last;
dst->count += to_push->count;
}
else if(to_push->first != 0)
{
rdim_memcpy_struct(dst, to_push);
}
rdim_memzero_struct(to_push);
}
////////////////////////////////
//~ rjf: [Serializing] Bake Results -> String Blobs
RDI_PROC RDIM_SerializedSection
rdim_serialized_section_make_unpacked(void *data, RDI_U64 size)
{
RDIM_SerializedSection s;
rdim_memzero_struct(&s);
s.data = data;
s.encoded_size = s.unpacked_size = size;
s.encoding = RDI_SectionEncoding_Unpacked;
return s;
}
RDI_PROC RDIM_SerializedSectionBundle
rdim_serialized_section_bundle_from_bake_results(RDIM_BakeResults *results)
{
RDIM_SerializedSectionBundle bundle;
rdim_memzero_struct(&bundle);
bundle.sections[RDI_SectionKind_TopLevelInfo] = rdim_serialized_section_make_unpacked_struct(&results->top_level_info.top_level_info);
bundle.sections[RDI_SectionKind_StringData] = rdim_serialized_section_make_unpacked_array(results->strings.string_data, results->strings.string_data_size);
bundle.sections[RDI_SectionKind_StringTable] = rdim_serialized_section_make_unpacked_array(results->strings.string_offs, results->strings.string_offs_count);
bundle.sections[RDI_SectionKind_IndexRuns] = rdim_serialized_section_make_unpacked_array(results->idx_runs.idx_runs, results->idx_runs.idx_count);
bundle.sections[RDI_SectionKind_BinarySections] = rdim_serialized_section_make_unpacked_array(results->binary_sections.binary_sections, results->binary_sections.binary_sections_count);
bundle.sections[RDI_SectionKind_FilePathNodes] = rdim_serialized_section_make_unpacked_array(results->file_paths.nodes, results->file_paths.nodes_count);
bundle.sections[RDI_SectionKind_SourceFiles] = rdim_serialized_section_make_unpacked_array(results->src_files.source_files, results->src_files.source_files_count);
bundle.sections[RDI_SectionKind_LineTables] = rdim_serialized_section_make_unpacked_array(results->line_tables.line_tables, results->line_tables.line_tables_count);
bundle.sections[RDI_SectionKind_LineInfoVOffs] = rdim_serialized_section_make_unpacked_array(results->line_tables.line_table_voffs, results->line_tables.line_table_voffs_count);
bundle.sections[RDI_SectionKind_LineInfoLines] = rdim_serialized_section_make_unpacked_array(results->line_tables.line_table_lines, results->line_tables.line_table_lines_count);
bundle.sections[RDI_SectionKind_LineInfoColumns] = rdim_serialized_section_make_unpacked_array(results->line_tables.line_table_columns, results->line_tables.line_table_columns_count);
bundle.sections[RDI_SectionKind_SourceLineMaps] = rdim_serialized_section_make_unpacked_array(results->src_files.source_line_maps, results->src_files.source_line_maps_count);
bundle.sections[RDI_SectionKind_SourceLineMapNumbers] = rdim_serialized_section_make_unpacked_array(results->src_files.source_line_map_nums, results->src_files.source_line_map_nums_count);
bundle.sections[RDI_SectionKind_SourceLineMapRanges] = rdim_serialized_section_make_unpacked_array(results->src_files.source_line_map_rngs, results->src_files.source_line_map_rngs_count);
bundle.sections[RDI_SectionKind_SourceLineMapVOffs] = rdim_serialized_section_make_unpacked_array(results->src_files.source_line_map_voffs, results->src_files.source_line_map_voffs_count);
bundle.sections[RDI_SectionKind_Units] = rdim_serialized_section_make_unpacked_array(results->units.units, results->units.units_count);
bundle.sections[RDI_SectionKind_UnitVMap] = rdim_serialized_section_make_unpacked_array(results->unit_vmap.vmap.vmap, results->unit_vmap.vmap.count);
bundle.sections[RDI_SectionKind_TypeNodes] = rdim_serialized_section_make_unpacked_array(results->type_nodes.type_nodes, results->type_nodes.type_nodes_count);
bundle.sections[RDI_SectionKind_UDTs] = rdim_serialized_section_make_unpacked_array(results->udts.udts, results->udts.udts_count);
bundle.sections[RDI_SectionKind_Members] = rdim_serialized_section_make_unpacked_array(results->udts.members, results->udts.members_count);
bundle.sections[RDI_SectionKind_EnumMembers] = rdim_serialized_section_make_unpacked_array(results->udts.enum_members, results->udts.enum_members_count);
bundle.sections[RDI_SectionKind_GlobalVariables] = rdim_serialized_section_make_unpacked_array(results->global_variables.global_variables, results->global_variables.global_variables_count);
bundle.sections[RDI_SectionKind_GlobalVMap] = rdim_serialized_section_make_unpacked_array(results->global_vmap.vmap.vmap, results->global_vmap.vmap.count);
bundle.sections[RDI_SectionKind_ThreadVariables] = rdim_serialized_section_make_unpacked_array(results->thread_variables.thread_variables, results->thread_variables.thread_variables_count);
bundle.sections[RDI_SectionKind_Constants] = rdim_serialized_section_make_unpacked_array(results->constants.constants, results->constants.constants_count);
bundle.sections[RDI_SectionKind_Procedures] = rdim_serialized_section_make_unpacked_array(results->procedures.procedures, results->procedures.procedures_count);
bundle.sections[RDI_SectionKind_Scopes] = rdim_serialized_section_make_unpacked_array(results->scopes.scopes, results->scopes.scopes_count);
bundle.sections[RDI_SectionKind_ScopeVOffData] = rdim_serialized_section_make_unpacked_array(results->scopes.scope_voffs, results->scopes.scope_voffs_count);
bundle.sections[RDI_SectionKind_ScopeVMap] = rdim_serialized_section_make_unpacked_array(results->scope_vmap.vmap.vmap, results->scope_vmap.vmap.count);
bundle.sections[RDI_SectionKind_InlineSites] = rdim_serialized_section_make_unpacked_array(results->inline_sites.inline_sites, results->inline_sites.inline_sites_count);
bundle.sections[RDI_SectionKind_Locals] = rdim_serialized_section_make_unpacked_array(results->scopes.locals, results->scopes.locals_count);
bundle.sections[RDI_SectionKind_LocationBlocks] = rdim_serialized_section_make_unpacked_array(results->location_blocks.str, results->location_blocks.size);
bundle.sections[RDI_SectionKind_LocationData] = rdim_serialized_section_make_unpacked_array(results->location_data.str, results->location_data.size);
if(results->location_blocks.size == 0)
{
bundle.sections[RDI_SectionKind_LocationBlocks] = rdim_serialized_section_make_unpacked_array(results->location_blocks2.location_blocks, results->location_blocks2.location_blocks_count);
bundle.sections[RDI_SectionKind_LocationData] = rdim_serialized_section_make_unpacked_array(results->locations.location_data, results->locations.location_data_size);
}
bundle.sections[RDI_SectionKind_ConstantValueData] = rdim_serialized_section_make_unpacked_array(results->constants.constant_value_data, results->constants.constant_value_data_size);
bundle.sections[RDI_SectionKind_ConstantValueTable] = rdim_serialized_section_make_unpacked_array(results->constants.constant_values, results->constants.constant_values_count);
bundle.sections[RDI_SectionKind_NameMaps] = rdim_serialized_section_make_unpacked_array(results->top_level_name_maps.name_maps, results->top_level_name_maps.name_maps_count);
bundle.sections[RDI_SectionKind_NameMapBuckets] = rdim_serialized_section_make_unpacked_array(results->name_maps.buckets, results->name_maps.buckets_count);
bundle.sections[RDI_SectionKind_NameMapNodes] = rdim_serialized_section_make_unpacked_array(results->name_maps.nodes, results->name_maps.nodes_count);
return bundle;
}
RDI_PROC RDIM_String8List
rdim_file_blobs_from_section_bundle(RDIM_Arena *arena, RDIM_SerializedSectionBundle *bundle)
{
RDIM_String8List strings;
rdim_memzero_struct(&strings);
{
RDIM_Temp scratch = rdim_scratch_begin(&arena, 1);
// rjf: push empty header & data section table
RDI_Header *rdi_header = rdim_push_array(arena, RDI_Header, 1);
RDI_Section *rdi_sections = rdim_push_array(arena, RDI_Section, RDI_SectionKind_COUNT);
rdim_str8_list_push(arena, &strings, rdim_str8_struct(rdi_header));
rdim_str8_list_push_align(arena, &strings, 8);
U32 data_section_off = (U32)strings.total_size;
rdim_str8_list_push(arena, &strings, rdim_str8((RDI_U8 *)rdi_sections, sizeof(RDI_Section)*RDI_SectionKind_COUNT));
// rjf: fill baked header
{
rdi_header->magic = RDI_MAGIC_CONSTANT;
rdi_header->encoding_version = RDI_ENCODING_VERSION;
rdi_header->data_section_off = data_section_off;
rdi_header->data_section_count = RDI_SectionKind_COUNT;
}
// rjf: fill baked data section table
for(RDI_SectionKind k = RDI_SectionKind_NULL; k < RDI_SectionKind_COUNT; k += 1)
{
RDI_Section *dst = rdi_sections+k;
U64 data_section_off = 0;
if(bundle->sections[k].encoded_size != 0)
{
rdim_str8_list_push_align(arena, &strings, 8);
data_section_off = strings.total_size;
rdim_str8_list_push(arena, &strings, rdim_str8((RDI_U8 *)bundle->sections[k].data, bundle->sections[k].encoded_size));
}
dst->encoding = bundle->sections[k].encoding;
dst->off = data_section_off;
dst->encoded_size = bundle->sections[k].encoded_size;
dst->unpacked_size = bundle->sections[k].unpacked_size;
}
rdim_scratch_end(scratch);
}
return strings;
}
Reference in New Issue View Git Blame Copy Permalink